From ef32a56dfdf4ef648bababdccb9576335d81285e Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Wed, 27 Nov 2024 16:58:18 -0300 Subject: [PATCH 01/11] - improve: refactor tests to work on deno and host --- Cargo.lock | 391 ++++++++++++++++-- libs/shinkai-tools-runner/Cargo.toml | 4 + libs/shinkai-tools-runner/src/lib.test.rs | 212 ++++++++-- .../src/tools/deno_execution_storage.rs | 2 +- .../src/tools/deno_execution_storage.test.rs | 4 +- .../src/tools/deno_runner.rs | 1 + .../src/tools/deno_runner.test.rs | 205 +++++---- .../src/tools/tool.test.rs | 118 +++++- 8 files changed, 768 insertions(+), 169 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b1dc665..2f04aaf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -122,6 +122,136 @@ dependencies = [ "derive_arbitrary", ] +[[package]] +name = "async-attributes" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3203e79f4dd9bdda415ed03cf14dae5a2bf775c683a00f94e9cd1faf0f596e5" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "async-channel" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35" +dependencies = [ + "concurrent-queue", + "event-listener 2.5.3", + "futures-core", +] + +[[package]] +name = "async-channel" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a" +dependencies = [ + "concurrent-queue", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-executor" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30ca9a001c1e8ba5149f91a74362376cc6bc5b919d92d988668657bd570bdcec" +dependencies = [ + "async-task", + "concurrent-queue", + "fastrand", + "futures-lite", + "slab", +] + +[[package]] +name = "async-global-executor" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c" +dependencies = [ + "async-channel 2.3.1", + "async-executor", + "async-io", + "async-lock", + "blocking", + "futures-lite", + "once_cell", +] + +[[package]] +name = "async-io" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43a2b323ccce0a1d90b449fd71f2a06ca7faa7c54c2751f06c9bd851fc061059" +dependencies = [ + "async-lock", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite", + "parking", + "polling", + "rustix", + "slab", + "tracing", + "windows-sys 0.59.0", +] + +[[package]] +name = "async-lock" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18" +dependencies = [ + "event-listener 5.3.1", + "event-listener-strategy", + "pin-project-lite", +] + +[[package]] +name = "async-std" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c634475f29802fde2b8f0b505b1bd00dfe4df7d4a000f0b36f7671197d5c3615" +dependencies = [ + "async-attributes", + "async-channel 1.9.0", + "async-global-executor", + "async-io", + "async-lock", + "crossbeam-utils", + "futures-channel", + "futures-core", + "futures-io", + "futures-lite", + "gloo-timers", + "kv-log-macro", + "log", + "memchr", + "once_cell", + "pin-project-lite", + "pin-utils", + "slab", + "wasm-bindgen-futures", +] + +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + [[package]] name = "autocfg" version = "1.3.0" @@ -180,6 +310,19 @@ dependencies = [ "generic-array", ] +[[package]] +name = "blocking" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703f41c54fc768e63e091340b424302bb1c29ef4aa0c7f10fe849dfb114d29ea" +dependencies = [ + "async-channel 2.3.1", + "async-task", + "futures-io", + "futures-lite", + "piper", +] + [[package]] name = "build-target" version = "0.4.0" @@ -278,6 +421,15 @@ version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "constant_time_eq" version = "0.3.0" @@ -400,7 +552,7 @@ checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -413,7 +565,7 @@ dependencies = [ "proc-macro2", "quote", "rustc_version", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -435,7 +587,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -456,7 +608,7 @@ dependencies = [ "proc-macro-error", "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -507,6 +659,33 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "event-listener" +version = "2.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" + +[[package]] +name = "event-listener" +version = "5.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba" +dependencies = [ + "concurrent-queue", + "parking", + "pin-project-lite", +] + +[[package]] +name = "event-listener-strategy" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1" +dependencies = [ + "event-listener 5.3.1", + "pin-project-lite", +] + [[package]] name = "fastrand" version = "2.1.1" @@ -607,6 +786,19 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" +[[package]] +name = "futures-lite" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cef40d21ae2c515b51041df9ed313ed21e572df340ea58a922a0aefe7e8891a1" +dependencies = [ + "fastrand", + "futures-core", + "futures-io", + "parking", + "pin-project-lite", +] + [[package]] name = "futures-macro" version = "0.3.30" @@ -615,7 +807,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -630,6 +822,12 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" +[[package]] +name = "futures-timer" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24" + [[package]] name = "futures-util" version = "0.3.30" @@ -681,6 +879,18 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" +[[package]] +name = "gloo-timers" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" +dependencies = [ + "futures-channel", + "futures-core", + "js-sys", + "wasm-bindgen", +] + [[package]] name = "h2" version = "0.3.26" @@ -702,9 +912,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.14.5" +version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" [[package]] name = "hermit-abi" @@ -712,6 +922,12 @@ version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" +[[package]] +name = "hermit-abi" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc" + [[package]] name = "hex-simd" version = "0.8.0" @@ -843,9 +1059,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.2.6" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" +checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da" dependencies = [ "equivalent", "hashbrown", @@ -896,6 +1112,15 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "kv-log-macro" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f" +dependencies = [ + "log", +] + [[package]] name = "lazy_static" version = "1.5.0" @@ -935,6 +1160,9 @@ name = "log" version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" +dependencies = [ + "value-bag", +] [[package]] name = "lzma-rs" @@ -1061,7 +1289,7 @@ version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" dependencies = [ - "hermit-abi", + "hermit-abi 0.3.9", "libc", ] @@ -1103,7 +1331,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -1130,6 +1358,12 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4030760ffd992bef45b0ae3f10ce1aba99e33464c90d14dd7c039884963ddc7a" +[[package]] +name = "parking" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" + [[package]] name = "parking_lot" version = "0.12.3" @@ -1210,7 +1444,7 @@ dependencies = [ "phf_shared", "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -1234,12 +1468,38 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "piper" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066" +dependencies = [ + "atomic-waker", + "fastrand", + "futures-io", +] + [[package]] name = "pkg-config" version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" +[[package]] +name = "polling" +version = "3.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi 0.4.0", + "pin-project-lite", + "rustix", + "tracing", + "windows-sys 0.59.0", +] + [[package]] name = "powerfmt" version = "0.2.0" @@ -1252,6 +1512,15 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" +[[package]] +name = "proc-macro-crate" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b" +dependencies = [ + "toml_edit", +] + [[package]] name = "proc-macro-error" version = "1.0.4" @@ -1287,9 +1556,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.36" +version = "1.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" dependencies = [ "proc-macro2", ] @@ -1362,6 +1631,12 @@ version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +[[package]] +name = "relative-path" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2" + [[package]] name = "reqwest" version = "0.11.27" @@ -1402,6 +1677,36 @@ dependencies = [ "winreg", ] +[[package]] +name = "rstest" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a2c585be59b6b5dd66a9d2084aa1d8bd52fbdb806eafdeffb52791147862035" +dependencies = [ + "futures", + "futures-timer", + "rstest_macros", + "rustc_version", +] + +[[package]] +name = "rstest_macros" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "825ea780781b15345a146be27eaefb05085e337e869bff01b4306a4fd4a9ad5a" +dependencies = [ + "cfg-if", + "glob", + "proc-macro-crate", + "proc-macro2", + "quote", + "regex", + "relative-path", + "rustc_version", + "syn 2.0.87", + "unicode-ident", +] + [[package]] name = "rustc-demangle" version = "0.1.24" @@ -1410,9 +1715,9 @@ checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" [[package]] name = "rustc_version" -version = "0.4.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" dependencies = [ "semver", ] @@ -1506,7 +1811,7 @@ checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -1548,6 +1853,7 @@ name = "shinkai_tools_runner" version = "0.0.0" dependencies = [ "anyhow", + "async-std", "base64-simd", "chrono", "copy_to_output", @@ -1565,6 +1871,7 @@ dependencies = [ "patch", "phf", "reqwest", + "rstest", "serde", "serde_json", "tempfile", @@ -1638,9 +1945,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.68" +version = "2.0.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9" +checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d" dependencies = [ "proc-macro2", "quote", @@ -1704,7 +2011,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -1768,7 +2075,7 @@ checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] @@ -1794,6 +2101,23 @@ dependencies = [ "tokio", ] +[[package]] +name = "toml_datetime" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" + +[[package]] +name = "toml_edit" +version = "0.22.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5" +dependencies = [ + "indexmap", + "toml_datetime", + "winnow", +] + [[package]] name = "tower-service" version = "0.3.2" @@ -1839,9 +2163,9 @@ checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" [[package]] name = "unicode-ident" -version = "1.0.12" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" +checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" [[package]] name = "unicode-normalization" @@ -1869,6 +2193,12 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" +[[package]] +name = "value-bag" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ef4c4aa54d5d05a279399bfa921ec387b7aba77caf7a682ae8d86785b8fdad2" + [[package]] name = "vcpkg" version = "0.2.15" @@ -1923,7 +2253,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", "wasm-bindgen-shared", ] @@ -1957,7 +2287,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -2135,6 +2465,15 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +[[package]] +name = "winnow" +version = "0.6.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b" +dependencies = [ + "memchr", +] + [[package]] name = "winreg" version = "0.50.0" @@ -2162,7 +2501,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.68", + "syn 2.0.87", ] [[package]] diff --git a/libs/shinkai-tools-runner/Cargo.toml b/libs/shinkai-tools-runner/Cargo.toml index ff9e073..b3df013 100644 --- a/libs/shinkai-tools-runner/Cargo.toml +++ b/libs/shinkai-tools-runner/Cargo.toml @@ -33,6 +33,10 @@ env_logger = "0.11.5" anyhow = { version = "1.0.93" } chrono = { version = "0.4.38" } +[dev-dependencies] +rstest = "0.23.0" +async-std = { version = "1.13", features = ["attributes"] } + [build-dependencies] copy_to_output = "2.2.0" glob = "0.3" diff --git a/libs/shinkai-tools-runner/src/lib.test.rs b/libs/shinkai-tools-runner/src/lib.test.rs index e215f18..499e6a2 100644 --- a/libs/shinkai-tools-runner/src/lib.test.rs +++ b/libs/shinkai-tools-runner/src/lib.test.rs @@ -2,14 +2,20 @@ use std::collections::HashMap; use std::env; use std::time::Duration; +use rstest::rstest; use serde_json::json; use crate::built_in_tools::get_tool; use crate::tools::code_files::CodeFiles; +use crate::tools::deno_runner_options::DenoRunnerOptions; +use crate::tools::deno_runner_options::RunnerType; use crate::tools::tool::Tool; +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_echo() { +async fn shinkai_tool_echo(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -19,7 +25,14 @@ async fn shinkai_tool_echo() { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run(None, serde_json::json!({ "message": "valparaíso" }), None) .await @@ -27,8 +40,11 @@ async fn shinkai_tool_echo() { assert_eq!(run_result.data["message"], "echoing: valparaíso"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_weather_by_city() { +async fn shinkai_tool_weather_by_city(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -41,7 +57,10 @@ async fn shinkai_tool_weather_by_city() { let tool = Tool::new( code_files, serde_json::json!({ "apiKey": "63d35ff6068c3103ccd1227526935675" }), - None, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), ); let run_result = tool .run(None, serde_json::json!({ "city": "valparaíso" }), None) @@ -49,8 +68,11 @@ async fn shinkai_tool_weather_by_city() { assert!(run_result.is_ok()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_inline() { +async fn shinkai_tool_inline(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -64,7 +86,14 @@ async fn shinkai_tool_inline() { files: HashMap::from([("main.ts".to_string(), js_code.to_string())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run(None, serde_json::json!({ "name": "world" }), None) .await @@ -72,8 +101,11 @@ async fn shinkai_tool_inline() { assert_eq!(run_result.data["message"], "Hello, world!"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_inline_non_json_return() { +async fn shinkai_tool_inline_non_json_return(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -87,13 +119,23 @@ async fn shinkai_tool_inline_non_json_return() { files: HashMap::from([("main.ts".to_string(), js_code.to_string())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool.run(None, serde_json::json!({}), None).await.unwrap(); assert_eq!(run_result.data, 5); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_web3_eth_balance() { +async fn shinkai_tool_web3_eth_balance(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -103,7 +145,14 @@ async fn shinkai_tool_web3_eth_balance() { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -115,8 +164,11 @@ async fn shinkai_tool_web3_eth_balance() { assert!(run_result.is_ok()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_web3_eth_uniswap() { +async fn shinkai_tool_web3_eth_uniswap(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -126,7 +178,14 @@ async fn shinkai_tool_web3_eth_uniswap() { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -144,8 +203,11 @@ async fn shinkai_tool_web3_eth_uniswap() { assert!(run_result.is_ok()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_download_page() { +async fn shinkai_tool_download_page(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -155,7 +217,14 @@ async fn shinkai_tool_download_page() { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -169,8 +238,11 @@ async fn shinkai_tool_download_page() { assert!(run_result.is_ok()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn max_execution_time() { +async fn max_execution_time(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -195,7 +267,14 @@ async fn max_execution_time() { files: HashMap::from([("main.ts".to_string(), js_code.to_string())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -207,8 +286,11 @@ async fn max_execution_time() { assert!(run_result.err().unwrap().message().contains("timed out")); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_download_page_stack_overflow() { +async fn shinkai_tool_download_page_stack_overflow(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -227,7 +309,14 @@ async fn shinkai_tool_download_page_stack_overflow() { )]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); tool.run( None, serde_json::json!({ @@ -245,8 +334,11 @@ async fn shinkai_tool_download_page_stack_overflow() { assert!(run_result.is_ok()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_leiden() { +async fn shinkai_tool_leiden(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -256,7 +348,14 @@ async fn shinkai_tool_leiden() { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let edges = vec![ (2, 1, 1), (3, 1, 1), @@ -353,8 +452,11 @@ async fn shinkai_tool_leiden() { ); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_duckduckgo_search() { +async fn shinkai_tool_duckduckgo_search(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -364,7 +466,14 @@ async fn shinkai_tool_duckduckgo_search() { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -384,8 +493,15 @@ async fn shinkai_tool_duckduckgo_search() { assert!(search_results[0].get("description").is_some()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_playwright_example() { +async fn shinkai_tool_playwright_example(#[case] runner_type: RunnerType) { + if cfg!(windows) { + eprintln!("Skipping test on Windows - Playwright not supported in Deno on Windows"); + return; + } let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -398,7 +514,10 @@ async fn shinkai_tool_playwright_example() { let tool = Tool::new( code_files, serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }), - None, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), ); let run_result = tool .run( @@ -419,8 +538,15 @@ async fn shinkai_tool_playwright_example() { ); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_defillama_lending_tvl_rankings() { +async fn shinkai_tool_defillama_lending_tvl_rankings(#[case] runner_type: RunnerType) { + if matches!(runner_type, RunnerType::Docker) || cfg!(windows) { + eprintln!("Skipping test in Docker environment or on Windows"); + return; + } let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -433,7 +559,10 @@ async fn shinkai_tool_defillama_lending_tvl_rankings() { let tool = Tool::new( code_files, serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }), - None, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), ); let run_result = tool .run( @@ -477,8 +606,11 @@ async fn shinkai_tool_defillama_lending_tvl_rankings() { // assert!(run_result.is_ok()); // } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_youtube_summary() { +async fn shinkai_tool_youtube_summary(#[case] runner_type: RunnerType) { if env::var("CI").unwrap_or(String::from("false")) == "true" { return; } @@ -490,14 +622,26 @@ async fn shinkai_tool_youtube_summary() { let configurations = if env::var("CI").unwrap_or(String::from("false")) == "true" { serde_json::json!({ "apiUrl": "https://api.openai.com/v1", "apiKey": env::var("OPEN_AI_API_KEY").unwrap(), "model": "gpt-4o-mini" }) } else { - serde_json::json!({ "apiUrl": "http://127.0.0.1:11434", "lang": "en" }) + let host = if matches!(runner_type, RunnerType::Docker) { + "host.docker.internal" + } else { + "127.0.0.1" + }; + serde_json::json!({ "apiUrl": format!("http://{}:11434", host), "lang": "en" }) }; let code_files = CodeFiles { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, configurations, None); + let tool = Tool::new( + code_files, + configurations, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -512,8 +656,11 @@ async fn shinkai_tool_youtube_summary() { .is_empty()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_json_to_md() { +async fn shinkai_tool_json_to_md(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -528,7 +675,10 @@ async fn shinkai_tool_json_to_md() { serde_json::json!({ "only_system": false }), - None, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), ); let message = serde_json::json!({ "relevantSentencesFromText": [ diff --git a/libs/shinkai-tools-runner/src/tools/deno_execution_storage.rs b/libs/shinkai-tools-runner/src/tools/deno_execution_storage.rs index d3eec3f..d06b7a1 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_execution_storage.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_execution_storage.rs @@ -105,7 +105,7 @@ impl DenoExecutionStorage { } log::info!("creating deno.json file"); let deno_json_path = self.code_folder_path.join("deno.json"); - std::fs::write(&deno_json_path, "{}").map_err(|e| { + std::fs::write(&deno_json_path, "").map_err(|e| { log::error!("failed to write deno.json file: {}", e); e })?; diff --git a/libs/shinkai-tools-runner/src/tools/deno_execution_storage.test.rs b/libs/shinkai-tools-runner/src/tools/deno_execution_storage.test.rs index 07c1055..afccfe7 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_execution_storage.test.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_execution_storage.test.rs @@ -6,7 +6,7 @@ use crate::tools::{ }; #[tokio::test] -async fn test_execution_storage_init() { +async fn execution_storage_init() { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -47,7 +47,7 @@ async fn test_execution_storage_init() { } #[tokio::test] -async fn test_execution_storage_clean_cache() { +async fn execution_storage_clean_cache() { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) diff --git a/libs/shinkai-tools-runner/src/tools/deno_runner.rs b/libs/shinkai-tools-runner/src/tools/deno_runner.rs index 680bd3f..7c2fa44 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_runner.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_runner.rs @@ -51,6 +51,7 @@ impl DenoRunner { .to_str() .unwrap(), ]) + .current_dir(execution_storage.code_folder_path.clone()) .stdout(std::process::Stdio::piped()) .stderr(std::process::Stdio::piped()) .kill_on_drop(true); diff --git a/libs/shinkai-tools-runner/src/tools/deno_runner.test.rs b/libs/shinkai-tools-runner/src/tools/deno_runner.test.rs index c412965..da321d2 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_runner.test.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_runner.test.rs @@ -1,3 +1,5 @@ +use rstest::rstest; + use crate::tools::{ code_files::CodeFiles, deno_execution_storage::DenoExecutionStorage, @@ -7,20 +9,29 @@ use crate::tools::{ }; use std::collections::HashMap; +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_run_echo_tool() { +async fn run_echo_tool(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) .try_init(); - let mut deno_runner = DenoRunner::default(); - let code = r#" - console.log('{"message":"hello world"}'); - "#; + let mut deno_runner = DenoRunner::new(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }); let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), code.to_string())]), + files: HashMap::from([( + "main.ts".to_string(), + r#" + console.log('{"message":"hello world"}'); + "# + .to_string(), + )]), entrypoint: "main.ts".to_string(), }; let result = deno_runner @@ -35,20 +46,29 @@ async fn test_run_echo_tool() { assert_eq!(result.first().unwrap(), "{\"message\":\"hello world\"}"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_run_with_env() { +async fn run_with_env(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) .try_init(); - let mut deno_runner = DenoRunner::default(); - let code = r#" - console.log(process.env.HELLO_WORLD); - "#; + let mut deno_runner = DenoRunner::new(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }); let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), code.to_string())]), + files: HashMap::from([( + "main.ts".to_string(), + r#" + console.log(process.env.HELLO_WORLD); + "# + .to_string(), + )]), entrypoint: "main.ts".to_string(), }; let mut envs = HashMap::::new(); @@ -58,31 +78,36 @@ async fn test_run_with_env() { assert_eq!(result.first().unwrap(), "hello world!"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_write_forbidden_folder() { +async fn write_forbidden_folder(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) .try_init(); let mut deno_runner = DenoRunner::new(DenoRunnerOptions { - force_runner_type: Some(RunnerType::Host), + force_runner_type: Some(runner_type), ..Default::default() }); - let code = r#" - try { - await Deno.writeTextFile("/test.txt", "This should fail"); - console.log('write succeeded'); - } catch (e) { - // We expect this to fail due to permissions - console.log('error', e); - throw e; - } - "#; - let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), code.to_string())]), + files: HashMap::from([( + "main.ts".to_string(), + r#" + try { + await Deno.writeTextFile("/test.txt", "This should fail"); + console.log('write succeeded'); + } catch (e) { + // We expect this to fail due to permissions + console.log('error', e); + throw e; + } + "# + .to_string(), + )]), entrypoint: "main.ts".to_string(), }; @@ -93,31 +118,36 @@ async fn test_write_forbidden_folder() { assert!(result.is_err()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_execution_storage_cache_contains_files() { +async fn execution_storage_cache_contains_files(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) .try_init(); - let test_dir = std::path::PathBuf::from("./shinkai-tools-runner-execution-storage"); - - let test_code = r#" - import { assertEquals } from "https://deno.land/std@0.201.0/assert/mod.ts"; - console.log('test'); - "#; let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), test_code.to_string())]), + files: HashMap::from([( + "main.ts".to_string(), + r#" + import { assertEquals } from "https://deno.land/std@0.201.0/assert/mod.ts"; + console.log('test'); + "# + .to_string(), + )]), entrypoint: "main.ts".to_string(), }; - let context_id = String::from("test-execution-cache"); + + let context_id = nanoid::nanoid!(); // Run the code to ensure dependencies are downloaded let mut deno_runner = DenoRunner::new(DenoRunnerOptions { context: ExecutionContext { - storage: test_dir.clone(), context_id: context_id.clone(), ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }); @@ -131,19 +161,28 @@ async fn test_execution_storage_cache_contains_files() { let storage = DenoExecutionStorage::new( empty_code_files, ExecutionContext { - storage: test_dir.clone(), context_id, ..Default::default() }, ); + log::info!( + "Deno cache folder: {}", + storage.deno_cache_folder_path.display() + ); assert!(storage.deno_cache_folder_path.exists()); let cache_files = std::fs::read_dir(&storage.deno_cache_folder_path).unwrap(); assert!(cache_files.count() > 0); } +#[rstest] +#[case::host(RunnerType::Host, "127.0.0.2")] +#[case::docker(RunnerType::Docker, "host.docker.internal")] #[tokio::test] -async fn test_run_with_shinkai_node_location_host() { +async fn run_with_shinkai_node_location_host( + #[case] runner_type: RunnerType, + #[case] expected_host: String, +) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -155,7 +194,7 @@ async fn test_run_with_shinkai_node_location_host() { host: String::from("127.0.0.2"), port: 9554, }, - force_runner_type: Some(RunnerType::Host), + force_runner_type: Some(runner_type), ..Default::default() }); let code = r#" @@ -166,41 +205,18 @@ async fn test_run_with_shinkai_node_location_host() { files: HashMap::from([("main.ts".to_string(), code.to_string())]), entrypoint: "main.ts".to_string(), }; - let result = deno_runner.run(code_files, None, None).await.unwrap(); - assert_eq!(result.first().unwrap(), "https://127.0.0.2:9554"); -} - -#[tokio::test] -async fn test_run_with_shinkai_node_location_docker() { - let _ = env_logger::builder() - .filter_level(log::LevelFilter::Info) - .is_test(true) - .try_init(); - - let mut deno_runner = DenoRunner::new(DenoRunnerOptions { - shinkai_node_location: ShinkaiNodeLocation { - protocol: String::from("https"), - host: String::from("127.0.0.2"), - port: 9554, - }, - force_runner_type: Some(RunnerType::Docker), - ..Default::default() - }); - let code = r#" - console.log(process.env.SHINKAI_NODE_LOCATION); - "#; - - let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), code.to_string())]), - entrypoint: "main.ts".to_string(), - }; - let result = deno_runner.run(code_files, None, None).await.unwrap(); - assert_eq!(result.first().unwrap(), "https://host.docker.internal:9554"); + assert_eq!( + result.first().unwrap().as_str(), + format!("https://{}:9554", expected_host) + ); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_run_with_file_sub_path() { +async fn run_with_file_sub_path(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -212,6 +228,7 @@ async fn test_run_with_file_sub_path() { host: String::from("127.0.0.2"), port: 9554, }, + force_runner_type: Some(runner_type), ..Default::default() }); let code = r#" @@ -226,8 +243,11 @@ async fn test_run_with_file_sub_path() { assert_eq!(result.first().unwrap(), "hello world"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_run_with_imports() { +async fn run_with_imports(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -239,6 +259,7 @@ async fn test_run_with_imports() { host: String::from("127.0.0.2"), port: 9554, }, + force_runner_type: Some(runner_type), ..Default::default() }); @@ -267,7 +288,7 @@ async fn test_run_with_imports() { } #[tokio::test] -async fn test_check_code_success() { +async fn check_code_success() { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -278,9 +299,9 @@ async fn test_check_code_success() { "main.ts".to_string(), String::from( r#" - import { assertEquals } from "https://deno.land/std@0.201.0/assert/mod.ts"; - console.log('test'); - "#, + // import { assertEquals } from "https://deno.land/std@0.201.0/assert/mod.ts"; + console.log('test'); + "#, ), )]), entrypoint: "main.ts".to_string(), @@ -288,9 +309,6 @@ async fn test_check_code_success() { // Run the code to ensure dependencies are downloaded let mut deno_runner = DenoRunner::new(DenoRunnerOptions { - context: ExecutionContext { - ..Default::default() - }, ..Default::default() }); @@ -298,8 +316,11 @@ async fn test_check_code_success() { assert_eq!(check_result.len(), 0); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_check_code_with_errors() { +async fn check_code_with_errors(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -310,8 +331,8 @@ async fn test_check_code_with_errors() { "main.ts".to_string(), String::from( r#" - console.log('test's); - "#, + console.log('test's); + "#, ), )]), entrypoint: "main.ts".to_string(), @@ -319,6 +340,7 @@ async fn test_check_code_with_errors() { // Run the code to ensure dependencies are downloaded let mut deno_runner = DenoRunner::new(DenoRunnerOptions { + force_runner_type: Some(runner_type), context: ExecutionContext { ..Default::default() }, @@ -327,11 +349,16 @@ async fn test_check_code_with_errors() { let check_result = deno_runner.check(code_files).await.unwrap(); assert!(!check_result.is_empty()); - assert!(check_result.contains(&String::from("Expected ',', got 's'"))); + assert!(check_result + .iter() + .any(|err| err.contains("Expected ',', got 's'"))); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_check_with_wrong_import_path() { +async fn check_with_wrong_import_path(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -352,6 +379,7 @@ async fn test_check_with_wrong_import_path() { // Run the code to ensure dependencies are downloaded let mut deno_runner = DenoRunner::new(DenoRunnerOptions { + force_runner_type: Some(runner_type), context: ExecutionContext { ..Default::default() }, @@ -363,7 +391,7 @@ async fn test_check_with_wrong_import_path() { } #[tokio::test] -async fn test_check_with_wrong_lib_version() { +async fn check_with_wrong_lib_version() { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -384,15 +412,12 @@ async fn test_check_with_wrong_lib_version() { // Run the code to ensure dependencies are downloaded let mut deno_runner = DenoRunner::new(DenoRunnerOptions { - context: ExecutionContext { - ..Default::default() - }, ..Default::default() }); let check_result = deno_runner.check(code_files).await.unwrap(); assert!(!check_result.is_empty()); - assert!(check_result.contains(&String::from( - "Could not find npm package 'axios' matching '3.4.2'" - ))); + assert!(check_result + .iter() + .any(|line| line.contains("Could not find npm package 'axios' matching '3.4.2'"))); } diff --git a/libs/shinkai-tools-runner/src/tools/tool.test.rs b/libs/shinkai-tools-runner/src/tools/tool.test.rs index 045226a..236ec47 100644 --- a/libs/shinkai-tools-runner/src/tools/tool.test.rs +++ b/libs/shinkai-tools-runner/src/tools/tool.test.rs @@ -1,14 +1,20 @@ use std::collections::HashMap; +use rstest::rstest; use serde_json::Value; use crate::tools::{ - code_files::CodeFiles, deno_runner_options::DenoRunnerOptions, - execution_context::ExecutionContext, tool::Tool, + code_files::CodeFiles, + deno_runner_options::{DenoRunnerOptions, RunnerType}, + execution_context::ExecutionContext, + tool::Tool, }; +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn get_tool_definition() { +async fn get_tool_definition(#[case] runner_type: RunnerType) { // Just for a simple test, it could be any tool let code = include_str!(concat!( env!("CARGO_MANIFEST_DIR"), @@ -23,15 +29,25 @@ async fn get_tool_definition() { let configurations = serde_json::json!({}); - let tool = Tool::new(code_files, configurations, None); + let tool = Tool::new( + code_files, + configurations, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let definition = tool.definition().await.unwrap(); assert_eq!(definition.id, "shinkai-tool-echo"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn run_tool() { +async fn run_tool(#[case] runner_type: RunnerType) { // Just for a simple test, it could be any tool let code = include_str!(concat!( env!("CARGO_MANIFEST_DIR"), @@ -46,7 +62,14 @@ async fn run_tool() { let configurations = Value::Null; - let tool = Tool::new(code_files, configurations, None); + let tool = Tool::new( + code_files, + configurations, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let result = tool .run( @@ -65,8 +88,11 @@ async fn run_tool() { ); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_with_env() { +async fn shinkai_tool_with_env(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -82,7 +108,14 @@ async fn shinkai_tool_with_env() { entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let mut envs = HashMap::::new(); envs.insert("BAR".to_string(), "bar".to_string()); let run_result = tool @@ -92,8 +125,11 @@ async fn shinkai_tool_with_env() { assert_eq!(run_result.unwrap().data["foo"], "bar"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_run_concurrency() { +async fn shinkai_tool_run_concurrency(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -159,6 +195,7 @@ async fn shinkai_tool_run_concurrency() { code_id: "js_code1".into(), ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }), ); @@ -206,8 +243,11 @@ async fn shinkai_tool_run_concurrency() { assert_eq!(run_result3.data["foo"], 10); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_file_persistence_in_home() { +async fn file_persistence_in_home(#[case] runner_type: RunnerType) { let js_code = r#" async function run(c, p) { const content = "Hello from tool!"; @@ -240,6 +280,7 @@ async fn test_file_persistence_in_home() { code_id: "js_code".into(), ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }), ); @@ -251,8 +292,11 @@ async fn test_file_persistence_in_home() { assert!(file_path.exists()); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_mount_file_in_mount() { +async fn mount_file_in_mount(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -288,6 +332,7 @@ async fn test_mount_file_in_mount() { mount_files: vec![test_file_path.to_path_buf().clone()], ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }), ); @@ -306,8 +351,11 @@ async fn test_mount_file_in_mount() { assert!(result.unwrap().data == "1"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_mount_and_edit_file_in_mount() { +async fn mount_and_edit_file_in_mount(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -341,6 +389,7 @@ async fn test_mount_and_edit_file_in_mount() { mount_files: vec![test_file_path.to_path_buf().clone()], ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }), ); @@ -362,8 +411,11 @@ async fn test_mount_and_edit_file_in_mount() { assert_eq!(content, "2"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_mount_file_in_assets() { +async fn mount_file_in_assets(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -397,6 +449,7 @@ async fn test_mount_file_in_assets() { assets_files: vec![test_file_path.to_path_buf().clone()], ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }), ); @@ -416,14 +469,20 @@ async fn test_mount_file_in_assets() { assert!(result.unwrap().data == "1"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_fail_when_try_write_assets() { +async fn fail_when_try_write_assets(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) .try_init(); - let test_file_path = tempfile::NamedTempFile::new_in("./shinkai-tools-runner-execution-storage").unwrap().into_temp_path(); + let test_file_path = + tempfile::NamedTempFile::new_in("./shinkai-tools-runner-execution-storage") + .unwrap() + .into_temp_path(); println!("test file path: {:?}", test_file_path); std::fs::write(&test_file_path, "1").unwrap(); @@ -455,6 +514,7 @@ async fn test_fail_when_try_write_assets() { assets_files: vec![test_file_path.to_path_buf().clone()], ..Default::default() }, + force_runner_type: Some(runner_type), ..Default::default() }), ); @@ -478,8 +538,11 @@ async fn test_fail_when_try_write_assets() { .contains("NotCapable")); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn shinkai_tool_param_with_quotes() { +async fn shinkai_tool_param_with_quotes(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -499,7 +562,14 @@ async fn shinkai_tool_param_with_quotes() { files: HashMap::from([("main.ts".to_string(), js_code.to_string())]), entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, serde_json::Value::Null, None); + let tool = Tool::new( + code_files, + serde_json::Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let run_result = tool .run( None, @@ -522,8 +592,11 @@ async fn shinkai_tool_param_with_quotes() { assert_eq!(result["escaped"], "escaped \' and \" quotes"); } +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] #[tokio::test] -async fn test_multiple_file_imports() { +async fn multiple_file_imports(#[case] runner_type: RunnerType) { let _ = env_logger::builder() .filter_level(log::LevelFilter::Info) .is_test(true) @@ -557,7 +630,14 @@ async fn test_multiple_file_imports() { entrypoint: "main.ts".to_string(), }; - let tool = Tool::new(code_files, Value::Null, None); + let tool = Tool::new( + code_files, + Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + ..Default::default() + }), + ); let result = tool.run(None, Value::Null, None).await; assert!(result.is_ok()); From 09f7af0c93c3ebd8c5f9f4e8c29827a158c26247 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Wed, 27 Nov 2024 17:02:49 -0300 Subject: [PATCH 02/11] - fix: lint errors --- apps/shinkai-tool-aave-loan-requester/src/index.ts | 7 ++++--- apps/shinkai-tool-aave-state/src/index.ts | 5 +++-- apps/shinkai-tool-defillama-tvl-rankings/src/index.ts | 2 +- apps/shinkai-tool-perplexity/src/index.ts | 2 +- 4 files changed, 9 insertions(+), 7 deletions(-) diff --git a/apps/shinkai-tool-aave-loan-requester/src/index.ts b/apps/shinkai-tool-aave-loan-requester/src/index.ts index 4345be1..d3df8c3 100644 --- a/apps/shinkai-tool-aave-loan-requester/src/index.ts +++ b/apps/shinkai-tool-aave-loan-requester/src/index.ts @@ -21,7 +21,7 @@ export const run: Run = async ( ): Promise => { const chromePath = configurations?.chromePath || - process.env.CHROME_PATH || + Deno.env.get('CHROME_PATH') || chromePaths.chrome || chromePaths.chromium; const browser = await playwright['chromium'].launch({ @@ -140,6 +140,7 @@ export const definition: ToolDefinition = { }; // attach-viem-script-content -const viemScriptContent = "(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.40";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    glideL1Protocol: () => glideL1Protocol,
    glideL2Protocol: () => glideL2Protocol,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    godwoken: () => godwoken,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    inkSepolia: () => inkSepolia,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    kardiaChain: () => kardiaChain,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    meld: () => meld,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morph: () => morph,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saakuru: () => saakuru,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    that: () => that,
    theta: () => theta,
    thetaTestnet: () => thetaTestnet,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tomb: () => tomb,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zeniq: () => zeniq,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL1Protocol.js
  var glideL1Protocol = /* @__PURE__ */ defineChain({
    id: 251,
    name: "Glide L1 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l1-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l1-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL2Protocol.js
  var glideL2Protocol = /* @__PURE__ */ defineChain({
    id: 253,
    name: "Glide L2 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l2-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l2-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/godwoken.js
  var godwoken = /* @__PURE__ */ defineChain({
    id: 71402,
    name: "Godwoken Mainnet",
    nativeCurrency: { decimals: 18, name: "pCKB", symbol: "pCKB" },
    rpcUrls: {
      default: {
        http: ["https://v1.mainnet.godwoken.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "GW Scan",
        url: "https://v1.gwscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 15034
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inkSepolia.js
  var sourceId19 = 11155111;
  var inkSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 763373,
    name: "Ink Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-gel-sepolia.inkonchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-sepolia.inkonchain.com/",
        apiUrl: "https://explorer-sepolia.inkonchain.com/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId19]: {
          address: "0x860e626c700af381133d9f4af31412a2d1db3d5d"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x5c1d29c6c9c8b0800692acc95d700bcb4966a1d7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x33f60714bbd74d62b66d79213c348614de51901c"
        }
      }
    },
    testnet: true,
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kardiaChain.js
  var kardiaChain = /* @__PURE__ */ defineChain({
    id: 24,
    name: "KardiaChain Mainnet",
    nativeCurrency: { name: "KAI", symbol: "KAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.kardiachain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "KardiaChain Explorer",
        url: "https://explorer.kardiachain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId20 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId20]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId20]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId21 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId21]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meld.js
  var meld = /* @__PURE__ */ defineChain({
    id: 333000333,
    name: "Meld",
    nativeCurrency: {
      decimals: 18,
      name: "Meld",
      symbol: "MELD"
    },
    rpcUrls: {
      default: { http: ["https://rpc-1.meld.com"] }
    },
    blockExplorers: {
      default: { name: "MELDscan", url: "https://meldscan.io" }
    },
    contracts: {
      multicall3: {
        address: "0x769ee5a8e82c15c1b6e358f62ac8eb6e3abe8dc5",
        blockCreated: 360069
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId22 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId22]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId23 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId24 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morph.js
  var morph = /* @__PURE__ */ defineChain({
    id: 2818,
    name: "Morph",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.morphl2.io"],
        webSocket: ["wss://rpc.morphl2.io:8443"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Explorer",
        url: "https://explorer.morphl2.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId25 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId26 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId26]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId27 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId27]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId27]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId28 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId28]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId28]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId29 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId29]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId29]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId30 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId30]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId30
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId31 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId31]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId31]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId31]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId31,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId32 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId32
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId33 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId33,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId33]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId34 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId34]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId35 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId35]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saakuru.js
  var saakuru = /* @__PURE__ */ defineChain({
    id: 7225878,
    name: "Saakuru Mainnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.saakuru.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saakuru Explorer",
        url: "https://explorer.saakuru.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId36 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId36]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId36]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId36]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId37 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId38 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId39 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId39]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId40 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId40]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId40]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/that.js
  var that = /* @__PURE__ */ defineChain({
    id: 8428,
    name: "THAT Mainnet",
    nativeCurrency: { name: "THAT", symbol: "THAT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.thatchain.io/mainnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://that.blockscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/theta.js
  var theta = /* @__PURE__ */ defineChain({
    id: 361,
    name: "Theta Mainnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thetaTestnet.js
  var thetaTestnet = /* @__PURE__ */ defineChain({
    id: 365,
    name: "Theta Testnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api-testnet.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://testnet-explorer.thetatoken.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tomb.js
  var tomb = /* @__PURE__ */ defineChain({
    id: 6969,
    name: "Tomb Mainnet",
    nativeCurrency: { name: "TOMB", symbol: "TOMB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.tombchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tomb Explorer",
        url: "https://tombscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId41 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId41]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId42 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId43 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId43]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId43]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId43]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://testnet.xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zeniq.js
  var zeniq = /* @__PURE__ */ defineChain({
    id: 383414847825,
    name: "Zeniq Mainnet",
    nativeCurrency: { name: "ZENIQ", symbol: "ZENIQ", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zeniq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zeniq Explorer",
        url: "https://zeniqscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId44 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId44]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId44
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId45 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId45]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId45]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId45]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId46 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId46]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId46,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    enable() {
      return this.requestAccounts();
    }
    request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return Promise.resolve(this.getAccounts());
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
"; - '(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.35";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId19 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId19]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId20 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId20]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId20]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId21 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId21]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId22 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId22]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId23 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId24 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId25 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId26 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId26]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId26]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId27 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId27]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId28 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId28]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId28]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId28]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId29 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId29]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId30 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId30]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId30,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId31 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId31
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId32 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId32,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId32]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId32]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId32]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId33 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId33]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId33
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId34 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId34]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId35 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId35]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId36 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId37 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId37]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId37]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId37]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId37]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId38 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId39 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId39]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId40 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId40]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId41 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId41]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId41]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId42 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "Blocksscan",
        url: "https://apothem.blocksscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId43 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId43]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId43]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId44 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId44]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId44,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId45 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId45]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    async enable() {
      return this.requestAccounts();
    }
    async request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return this.getAccounts();
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    async getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    async sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'; +const viemScriptContent = + '(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.40";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    glideL1Protocol: () => glideL1Protocol,
    glideL2Protocol: () => glideL2Protocol,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    godwoken: () => godwoken,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    inkSepolia: () => inkSepolia,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    kardiaChain: () => kardiaChain,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    meld: () => meld,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morph: () => morph,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saakuru: () => saakuru,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    that: () => that,
    theta: () => theta,
    thetaTestnet: () => thetaTestnet,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tomb: () => tomb,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zeniq: () => zeniq,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL1Protocol.js
  var glideL1Protocol = /* @__PURE__ */ defineChain({
    id: 251,
    name: "Glide L1 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l1-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l1-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL2Protocol.js
  var glideL2Protocol = /* @__PURE__ */ defineChain({
    id: 253,
    name: "Glide L2 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l2-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l2-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/godwoken.js
  var godwoken = /* @__PURE__ */ defineChain({
    id: 71402,
    name: "Godwoken Mainnet",
    nativeCurrency: { decimals: 18, name: "pCKB", symbol: "pCKB" },
    rpcUrls: {
      default: {
        http: ["https://v1.mainnet.godwoken.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "GW Scan",
        url: "https://v1.gwscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 15034
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inkSepolia.js
  var sourceId19 = 11155111;
  var inkSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 763373,
    name: "Ink Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-gel-sepolia.inkonchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-sepolia.inkonchain.com/",
        apiUrl: "https://explorer-sepolia.inkonchain.com/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId19]: {
          address: "0x860e626c700af381133d9f4af31412a2d1db3d5d"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x5c1d29c6c9c8b0800692acc95d700bcb4966a1d7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x33f60714bbd74d62b66d79213c348614de51901c"
        }
      }
    },
    testnet: true,
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kardiaChain.js
  var kardiaChain = /* @__PURE__ */ defineChain({
    id: 24,
    name: "KardiaChain Mainnet",
    nativeCurrency: { name: "KAI", symbol: "KAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.kardiachain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "KardiaChain Explorer",
        url: "https://explorer.kardiachain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId20 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId20]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId20]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId21 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId21]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meld.js
  var meld = /* @__PURE__ */ defineChain({
    id: 333000333,
    name: "Meld",
    nativeCurrency: {
      decimals: 18,
      name: "Meld",
      symbol: "MELD"
    },
    rpcUrls: {
      default: { http: ["https://rpc-1.meld.com"] }
    },
    blockExplorers: {
      default: { name: "MELDscan", url: "https://meldscan.io" }
    },
    contracts: {
      multicall3: {
        address: "0x769ee5a8e82c15c1b6e358f62ac8eb6e3abe8dc5",
        blockCreated: 360069
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId22 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId22]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId23 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId24 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morph.js
  var morph = /* @__PURE__ */ defineChain({
    id: 2818,
    name: "Morph",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.morphl2.io"],
        webSocket: ["wss://rpc.morphl2.io:8443"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Explorer",
        url: "https://explorer.morphl2.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId25 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId26 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId26]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId27 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId27]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId27]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId28 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId28]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId28]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId29 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId29]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId29]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId30 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId30]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId30
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId31 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId31]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId31]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId31]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId31,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId32 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId32
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId33 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId33,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId33]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId34 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId34]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId35 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId35]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saakuru.js
  var saakuru = /* @__PURE__ */ defineChain({
    id: 7225878,
    name: "Saakuru Mainnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.saakuru.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saakuru Explorer",
        url: "https://explorer.saakuru.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId36 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId36]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId36]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId36]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId37 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId38 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId39 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId39]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId40 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId40]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId40]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/that.js
  var that = /* @__PURE__ */ defineChain({
    id: 8428,
    name: "THAT Mainnet",
    nativeCurrency: { name: "THAT", symbol: "THAT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.thatchain.io/mainnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://that.blockscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/theta.js
  var theta = /* @__PURE__ */ defineChain({
    id: 361,
    name: "Theta Mainnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thetaTestnet.js
  var thetaTestnet = /* @__PURE__ */ defineChain({
    id: 365,
    name: "Theta Testnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api-testnet.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://testnet-explorer.thetatoken.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tomb.js
  var tomb = /* @__PURE__ */ defineChain({
    id: 6969,
    name: "Tomb Mainnet",
    nativeCurrency: { name: "TOMB", symbol: "TOMB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.tombchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tomb Explorer",
        url: "https://tombscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId41 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId41]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId42 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId43 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId43]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId43]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId43]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://testnet.xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zeniq.js
  var zeniq = /* @__PURE__ */ defineChain({
    id: 383414847825,
    name: "Zeniq Mainnet",
    nativeCurrency: { name: "ZENIQ", symbol: "ZENIQ", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zeniq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zeniq Explorer",
        url: "https://zeniqscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId44 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId44]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId44
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId45 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId45]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId45]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId45]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId46 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId46]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId46,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    enable() {
      return this.requestAccounts();
    }
    request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return Promise.resolve(this.getAccounts());
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzY3IiBoZWlnaHQ9IjM2NyIgdmlld0JveD0iMCAwIDM2NyAzNjciIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxjaXJjbGUgY3g9IjE4My41IiBjeT0iMTgzLjUiIHI9IjE4My41IiBmaWxsPSIjRkU2MTYyIi8+CjxwYXRoIGQ9Ik0yNzIuMjk1IDI3NC42NjhDMjcwLjc1OCAyNjguOTc1IDI2Ni42MTkgMjY2LjIxNSAyNjAuODQ0IDI2Ni43NzlDMjQ5LjY2NCAyNjcuODYzIDI0NS45NTIgMjY0LjI3OSAyNDAuNjQ2IDI1Ni40MDRDMjU0LjYyOCAyNTkuMzY3IDI2My42NDYgMjU1LjcyNSAyNjYuNDYzIDI1NC4xMDdDMjcwLjA5IDI1Mi4wMTIgMjczLjc2IDI0OS4zMjQgMjcyLjMwOSAyNDQuNTg1QzI3MC44ODYgMjM5Ljk0NyAyNjYuNjE5IDIzOS4wMjIgMjYyLjIzOCAyMzkuODZDMjU2LjAyMiAyNDEuMDQ1IDI1MC4wNjIgMjQxLjczOCAyNDUuMjI2IDIzNS42ODRDMjQ2LjI1IDIzNC43NTkgMjQ3LjI3NCAyMzMuODA2IDI0OC4zMjcgMjMyLjg5NUMyNTAuOTAyIDIzMC42ODUgMjUyLjg5MyAyMjguMDg0IDI1MS41ODQgMjI0LjU3M0MyNTAuMzMzIDIyMS4yMiAyNDcuMTYxIDIxOS4yOTkgMjQzLjkzMiAyMTkuODkxQzI0MS4zIDIyMC4zODIgMjM2LjAyMyAyMjIuMDMgMjM0LjQxNiAyMTkuMzQyTDIzNC40ODcgMjE5LjMxM0MyMzMuODc1IDIxOS4xNjkgMjMyLjkzNyAyMTYuNjU0IDIzMi43MzcgMjE0LjgxOUMyMzEuNzk5IDIwNS44NDYgMjM1LjY4MiAxOTcuMjM1IDI0MC45MTYgMTkwLjA4MkMyNDcuNDQ1IDE4MS4xOTYgMjUxLjkyNiAxNzEuMzk5IDI1My45MTcgMTYwLjUzM0MyNTcuMDMyIDE0My40ODMgMjUzLjczMiAxMjcuNjE4IDI0NC41MTUgMTEzLjAzOUMyMzMuNTc3IDk1LjcyODMgMjE4LjE1OCA4NC4zMjc4IDE5Ny44NiA4MC4xMzc1QzE5My4wOTUgNzkuMTU1IDE4OC40NDQgNzguNjM0OCAxODMuOTM1IDc4LjU0ODFDMTc5LjQxMSA3OC42MzQ4IDE3NC43NzQgNzkuMTU1IDE3MC4wMDkgODAuMTM3NUMxNDkuNzI2IDg0LjMyNzggMTM0LjI5MyA5NS43MjgzIDEyMy4zNTQgMTEzLjAzOUMxMTQuMTUxIDEyNy42MTggMTEwLjg1MSAxNDMuNDgzIDExMy45NTIgMTYwLjUzM0MxMTUuOTI5IDE3MS40MTQgMTIwLjQyNCAxODEuMTk2IDEyNi45NTMgMTkwLjA4MkMxMzIuMjAyIDE5Ny4yMzUgMTM2LjA4NSAyMDUuODMyIDEzNS4xMzIgMjE0LjgxOUMxMzQuOTMzIDIxNi42NTQgMTMzLjk5NCAyMTkuMTY5IDEzMy4zODIgMjE5LjMxM0wxMzMuNDUzIDIxOS4zNDJDMTMxLjg0NiAyMjIuMDE1IDEyNi41ODMgMjIwLjM4MiAxMjMuOTM4IDIxOS44OTFDMTIwLjcyMyAyMTkuMjk5IDExNy41MzcgMjIxLjIyIDExNi4yODUgMjI0LjU3M0MxMTQuOTc2IDIyOC4wODQgMTE2Ljk1NCAyMzAuNjg1IDExOS41NDIgMjMyLjg5NUMxMjAuNTk1IDIzMy44MDYgMTIxLjYxOSAyMzQuNzU5IDEyMi42NDMgMjM1LjY4NEMxMTcuODA3IDI0MS43MzggMTExLjgzMyAyNDEuMDQ1IDEwNS42MzEgMjM5Ljg2QzEwMS4yNSAyMzkuMDIyIDk2Ljk4MjkgMjM5Ljk0NyA5NS41NjA1IDI0NC41ODVDOTQuMTA5NyAyNDkuMzI0IDk3Ljc3OTUgMjUyLjAxMiAxMDEuNDA3IDI1NC4xMDdDMTA0LjIwOSAyNTUuNzI1IDExMy4yNDEgMjU5LjM1MiAxMjcuMjIzIDI1Ni40MDRDMTIxLjkxOCAyNjQuMjc5IDExOC4yMDUgMjY3Ljg2MyAxMDcuMDI1IDI2Ni43NzlDMTAxLjI1IDI2Ni4yMTUgOTcuMDk2NyAyNjguOTc1IDk1LjU3NDcgMjc0LjY2OEM5NC4wODEyIDI4MC4yMzEgOTcuMDI1NiAyODQuMjE5IDEwMS42OTEgMjg2Ljg3OEMxMDQuNzQ5IDI4OC42MTIgMTA4LjE2MyAyODkuMjkxIDExMS43NzYgMjg5LjM0OUMxMzEuNTYyIDI4OS42MjMgMTQ3Ljg5MSAyODEuNDU5IDE2Mi41OTkgMjY5LjE3OEMxNzAuNjkyIDI2Mi40MTUgMTc3LjM0OSAyNTguOTkxIDE4My45NDkgMjU4LjkwNEMxOTAuNTQ5IDI1OC45OTEgMTk3LjE5MSAyNjIuNDE1IDIwNS4yOTkgMjY5LjE3OEMyMjAuMDA3IDI4MS40NTkgMjM2LjMzNiAyODkuNjIzIDI1Ni4xMjIgMjg5LjM0OUMyNTkuNzM1IDI4OS4zMDUgMjYzLjE0OCAyODguNjEyIDI2Ni4yMDcgMjg2Ljg3OEMyNzAuODg2IDI4NC4yMTkgMjczLjgxNyAyODAuMjMxIDI3Mi4zMjMgMjc0LjY2OEgyNzIuMjk1Wk0xNTYuNjI0IDIwNy4yNjJDMTUwLjUwOCAyMDcuMjQ4IDE0NS40NTkgMjAyLjEzMyAxNDUuNDQ0IDE5NS45NjNDMTQ1LjQ0NCAxODkuNjc4IDE1MC41NTEgMTg0LjUzNCAxNTYuODUyIDE4NC40NzZDMTYyLjg0IDE4NC40MTggMTY4LjE3NCAxOTAuMDk3IDE2OC4xMTcgMTk2LjQ2OUMxNjguMDYxIDIwMi43ODMgMTYzLjI1MyAyMDcuMjkxIDE1Ni42MjQgMjA3LjI2MlpNMjExLjIzMSAyMDcuMjYyQzIwNC41ODggMjA3LjI5MSAxOTkuNzk1IDIwMi43NjkgMTk5LjczOCAxOTYuNDY5QzE5OS42ODEgMTkwLjA5NyAyMDUuMDI5IDE4NC40MTggMjExLjAwMyAxODQuNDc2QzIxNy4zMDQgMTg0LjU0OCAyMjIuNDExIDE4OS42OTIgMjIyLjQxMSAxOTUuOTYzQzIyMi40MTEgMjAyLjEzMyAyMTcuMzQ3IDIwNy4yNDggMjExLjIzMSAyMDcuMjYyWiIgZmlsbD0id2hpdGUiLz4KPC9zdmc+Cg==",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'; +('(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.35";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId19 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId19]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId20 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId20]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId20]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId21 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId21]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId22 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId22]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId23 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId24 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId25 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId26 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId26]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId26]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId27 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId27]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId28 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId28]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId28]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId28]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId29 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId29]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId30 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId30]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId30,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId31 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId31
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId32 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId32,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId32]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId32]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId32]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId33 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId33]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId33
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId34 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId34]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId35 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId35]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId36 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId37 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId37]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId37]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId37]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId37]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId38 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId39 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId39]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId40 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId40]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId41 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId41]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId41]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId42 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "Blocksscan",
        url: "https://apothem.blocksscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId43 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId43]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId43]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId44 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId44]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId44,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId45 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId45]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    async enable() {
      return this.requestAccounts();
    }
    async request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return this.getAccounts();
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    async getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    async sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'); ('(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.35";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId19 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId19]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId20 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId20]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId20]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId21 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId21]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId22 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId22]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId23 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId24 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId25 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId26 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId26]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId26]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId27 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId27]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId28 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId28]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId28]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId28]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId29 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId29]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId30 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId30]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId30,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId31 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId31
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId32 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId32,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId32]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId32]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId32]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId33 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId33]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId33
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId34 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId34]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId35 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId35]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId36 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId37 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId37]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId37]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId37]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId37]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId38 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId39 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId39]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId40 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId40]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId41 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId41]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId41]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId42 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "Blocksscan",
        url: "https://apothem.blocksscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId43 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId43]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId43]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId44 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId44]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId44,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId45 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId45]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    async enable() {
      return this.requestAccounts();
    }
    async request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return this.getAccounts();
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    async getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    async sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'); diff --git a/apps/shinkai-tool-aave-state/src/index.ts b/apps/shinkai-tool-aave-state/src/index.ts index b1c7c05..ad8534a 100644 --- a/apps/shinkai-tool-aave-state/src/index.ts +++ b/apps/shinkai-tool-aave-state/src/index.ts @@ -19,7 +19,7 @@ export const run: Run = async ( ): Promise => { const chromePath = configurations?.chromePath || - process.env.CHROME_PATH || + Deno.env.get('CHROME_PATH') || chromePaths.chrome || chromePaths.chromium; const browser = await playwright['chromium'].launch({ @@ -117,7 +117,8 @@ export const definition: ToolDefinition = { }; // attach-viem-script-content -const viemScriptContent = "(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.40";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    glideL1Protocol: () => glideL1Protocol,
    glideL2Protocol: () => glideL2Protocol,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    godwoken: () => godwoken,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    inkSepolia: () => inkSepolia,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    kardiaChain: () => kardiaChain,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    meld: () => meld,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morph: () => morph,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saakuru: () => saakuru,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    that: () => that,
    theta: () => theta,
    thetaTestnet: () => thetaTestnet,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tomb: () => tomb,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zeniq: () => zeniq,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL1Protocol.js
  var glideL1Protocol = /* @__PURE__ */ defineChain({
    id: 251,
    name: "Glide L1 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l1-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l1-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL2Protocol.js
  var glideL2Protocol = /* @__PURE__ */ defineChain({
    id: 253,
    name: "Glide L2 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l2-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l2-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/godwoken.js
  var godwoken = /* @__PURE__ */ defineChain({
    id: 71402,
    name: "Godwoken Mainnet",
    nativeCurrency: { decimals: 18, name: "pCKB", symbol: "pCKB" },
    rpcUrls: {
      default: {
        http: ["https://v1.mainnet.godwoken.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "GW Scan",
        url: "https://v1.gwscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 15034
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inkSepolia.js
  var sourceId19 = 11155111;
  var inkSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 763373,
    name: "Ink Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-gel-sepolia.inkonchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-sepolia.inkonchain.com/",
        apiUrl: "https://explorer-sepolia.inkonchain.com/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId19]: {
          address: "0x860e626c700af381133d9f4af31412a2d1db3d5d"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x5c1d29c6c9c8b0800692acc95d700bcb4966a1d7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x33f60714bbd74d62b66d79213c348614de51901c"
        }
      }
    },
    testnet: true,
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kardiaChain.js
  var kardiaChain = /* @__PURE__ */ defineChain({
    id: 24,
    name: "KardiaChain Mainnet",
    nativeCurrency: { name: "KAI", symbol: "KAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.kardiachain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "KardiaChain Explorer",
        url: "https://explorer.kardiachain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId20 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId20]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId20]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId21 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId21]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meld.js
  var meld = /* @__PURE__ */ defineChain({
    id: 333000333,
    name: "Meld",
    nativeCurrency: {
      decimals: 18,
      name: "Meld",
      symbol: "MELD"
    },
    rpcUrls: {
      default: { http: ["https://rpc-1.meld.com"] }
    },
    blockExplorers: {
      default: { name: "MELDscan", url: "https://meldscan.io" }
    },
    contracts: {
      multicall3: {
        address: "0x769ee5a8e82c15c1b6e358f62ac8eb6e3abe8dc5",
        blockCreated: 360069
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId22 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId22]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId23 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId24 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morph.js
  var morph = /* @__PURE__ */ defineChain({
    id: 2818,
    name: "Morph",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.morphl2.io"],
        webSocket: ["wss://rpc.morphl2.io:8443"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Explorer",
        url: "https://explorer.morphl2.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId25 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId26 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId26]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId27 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId27]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId27]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId28 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId28]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId28]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId29 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId29]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId29]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId30 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId30]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId30
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId31 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId31]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId31]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId31]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId31,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId32 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId32
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId33 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId33,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId33]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId34 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId34]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId35 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId35]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saakuru.js
  var saakuru = /* @__PURE__ */ defineChain({
    id: 7225878,
    name: "Saakuru Mainnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.saakuru.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saakuru Explorer",
        url: "https://explorer.saakuru.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId36 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId36]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId36]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId36]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId37 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId38 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId39 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId39]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId40 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId40]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId40]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/that.js
  var that = /* @__PURE__ */ defineChain({
    id: 8428,
    name: "THAT Mainnet",
    nativeCurrency: { name: "THAT", symbol: "THAT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.thatchain.io/mainnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://that.blockscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/theta.js
  var theta = /* @__PURE__ */ defineChain({
    id: 361,
    name: "Theta Mainnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thetaTestnet.js
  var thetaTestnet = /* @__PURE__ */ defineChain({
    id: 365,
    name: "Theta Testnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api-testnet.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://testnet-explorer.thetatoken.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tomb.js
  var tomb = /* @__PURE__ */ defineChain({
    id: 6969,
    name: "Tomb Mainnet",
    nativeCurrency: { name: "TOMB", symbol: "TOMB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.tombchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tomb Explorer",
        url: "https://tombscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId41 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId41]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId42 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId43 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId43]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId43]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId43]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://testnet.xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zeniq.js
  var zeniq = /* @__PURE__ */ defineChain({
    id: 383414847825,
    name: "Zeniq Mainnet",
    nativeCurrency: { name: "ZENIQ", symbol: "ZENIQ", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zeniq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zeniq Explorer",
        url: "https://zeniqscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId44 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId44]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId44
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId45 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId45]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId45]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId45]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId46 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId46]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId46,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    enable() {
      return this.requestAccounts();
    }
    request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return Promise.resolve(this.getAccounts());
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
"; +const viemScriptContent = '(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.40";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    glideL1Protocol: () => glideL1Protocol,
    glideL2Protocol: () => glideL2Protocol,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    godwoken: () => godwoken,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    inkSepolia: () => inkSepolia,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    kardiaChain: () => kardiaChain,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    meld: () => meld,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morph: () => morph,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saakuru: () => saakuru,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    that: () => that,
    theta: () => theta,
    thetaTestnet: () => thetaTestnet,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tomb: () => tomb,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zeniq: () => zeniq,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL1Protocol.js
  var glideL1Protocol = /* @__PURE__ */ defineChain({
    id: 251,
    name: "Glide L1 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l1-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l1-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL2Protocol.js
  var glideL2Protocol = /* @__PURE__ */ defineChain({
    id: 253,
    name: "Glide L2 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l2-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l2-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/godwoken.js
  var godwoken = /* @__PURE__ */ defineChain({
    id: 71402,
    name: "Godwoken Mainnet",
    nativeCurrency: { decimals: 18, name: "pCKB", symbol: "pCKB" },
    rpcUrls: {
      default: {
        http: ["https://v1.mainnet.godwoken.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "GW Scan",
        url: "https://v1.gwscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 15034
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inkSepolia.js
  var sourceId19 = 11155111;
  var inkSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 763373,
    name: "Ink Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-gel-sepolia.inkonchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-sepolia.inkonchain.com/",
        apiUrl: "https://explorer-sepolia.inkonchain.com/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId19]: {
          address: "0x860e626c700af381133d9f4af31412a2d1db3d5d"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x5c1d29c6c9c8b0800692acc95d700bcb4966a1d7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x33f60714bbd74d62b66d79213c348614de51901c"
        }
      }
    },
    testnet: true,
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kardiaChain.js
  var kardiaChain = /* @__PURE__ */ defineChain({
    id: 24,
    name: "KardiaChain Mainnet",
    nativeCurrency: { name: "KAI", symbol: "KAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.kardiachain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "KardiaChain Explorer",
        url: "https://explorer.kardiachain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId20 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId20]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId20]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId21 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId21]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meld.js
  var meld = /* @__PURE__ */ defineChain({
    id: 333000333,
    name: "Meld",
    nativeCurrency: {
      decimals: 18,
      name: "Meld",
      symbol: "MELD"
    },
    rpcUrls: {
      default: { http: ["https://rpc-1.meld.com"] }
    },
    blockExplorers: {
      default: { name: "MELDscan", url: "https://meldscan.io" }
    },
    contracts: {
      multicall3: {
        address: "0x769ee5a8e82c15c1b6e358f62ac8eb6e3abe8dc5",
        blockCreated: 360069
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId22 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId22]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId23 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId24 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morph.js
  var morph = /* @__PURE__ */ defineChain({
    id: 2818,
    name: "Morph",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.morphl2.io"],
        webSocket: ["wss://rpc.morphl2.io:8443"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Explorer",
        url: "https://explorer.morphl2.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId25 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId26 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId26]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId27 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId27]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId27]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId28 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId28]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId28]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId29 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId29]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId29]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId30 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId30]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId30
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId31 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId31]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId31]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId31]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId31,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId32 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId32
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId33 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId33,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId33]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId34 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId34]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId35 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId35]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saakuru.js
  var saakuru = /* @__PURE__ */ defineChain({
    id: 7225878,
    name: "Saakuru Mainnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.saakuru.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saakuru Explorer",
        url: "https://explorer.saakuru.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId36 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId36]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId36]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId36]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId37 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId38 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId39 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId39]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId40 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId40]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId40]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/that.js
  var that = /* @__PURE__ */ defineChain({
    id: 8428,
    name: "THAT Mainnet",
    nativeCurrency: { name: "THAT", symbol: "THAT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.thatchain.io/mainnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://that.blockscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/theta.js
  var theta = /* @__PURE__ */ defineChain({
    id: 361,
    name: "Theta Mainnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thetaTestnet.js
  var thetaTestnet = /* @__PURE__ */ defineChain({
    id: 365,
    name: "Theta Testnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api-testnet.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://testnet-explorer.thetatoken.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tomb.js
  var tomb = /* @__PURE__ */ defineChain({
    id: 6969,
    name: "Tomb Mainnet",
    nativeCurrency: { name: "TOMB", symbol: "TOMB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.tombchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tomb Explorer",
        url: "https://tombscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId41 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId41]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId42 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId43 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId43]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId43]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId43]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://testnet.xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zeniq.js
  var zeniq = /* @__PURE__ */ defineChain({
    id: 383414847825,
    name: "Zeniq Mainnet",
    nativeCurrency: { name: "ZENIQ", symbol: "ZENIQ", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zeniq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zeniq Explorer",
        url: "https://zeniqscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId44 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId44]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId44
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId45 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId45]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId45]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId45]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId46 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId46]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId46,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    enable() {
      return this.requestAccounts();
    }
    request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return Promise.resolve(this.getAccounts());
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'; +('(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.40";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    glideL1Protocol: () => glideL1Protocol,
    glideL2Protocol: () => glideL2Protocol,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    godwoken: () => godwoken,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    inkSepolia: () => inkSepolia,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    kardiaChain: () => kardiaChain,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    meld: () => meld,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morph: () => morph,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saakuru: () => saakuru,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    that: () => that,
    theta: () => theta,
    thetaTestnet: () => thetaTestnet,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tomb: () => tomb,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zeniq: () => zeniq,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL1Protocol.js
  var glideL1Protocol = /* @__PURE__ */ defineChain({
    id: 251,
    name: "Glide L1 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l1-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l1-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/glideL2Protocol.js
  var glideL2Protocol = /* @__PURE__ */ defineChain({
    id: 253,
    name: "Glide L2 Protocol XP",
    nativeCurrency: { name: "GLXP", symbol: "GLXP", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-api.glideprotocol.xyz/l2-rpc"],
        webSocket: ["wss://rpc-api.glideprotocol.xyz/l2-rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Glide Protocol Explore",
        url: "https://blockchain-explorer.glideprotocol.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/godwoken.js
  var godwoken = /* @__PURE__ */ defineChain({
    id: 71402,
    name: "Godwoken Mainnet",
    nativeCurrency: { decimals: 18, name: "pCKB", symbol: "pCKB" },
    rpcUrls: {
      default: {
        http: ["https://v1.mainnet.godwoken.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "GW Scan",
        url: "https://v1.gwscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 15034
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/inkSepolia.js
  var sourceId19 = 11155111;
  var inkSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 763373,
    name: "Ink Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-gel-sepolia.inkonchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-sepolia.inkonchain.com/",
        apiUrl: "https://explorer-sepolia.inkonchain.com/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId19]: {
          address: "0x860e626c700af381133d9f4af31412a2d1db3d5d"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x5c1d29c6c9c8b0800692acc95d700bcb4966a1d7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x33f60714bbd74d62b66d79213c348614de51901c"
        }
      }
    },
    testnet: true,
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kardiaChain.js
  var kardiaChain = /* @__PURE__ */ defineChain({
    id: 24,
    name: "KardiaChain Mainnet",
    nativeCurrency: { name: "KAI", symbol: "KAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.kardiachain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "KardiaChain Explorer",
        url: "https://explorer.kardiachain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId20 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId20]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId20]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId21 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId21]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meld.js
  var meld = /* @__PURE__ */ defineChain({
    id: 333000333,
    name: "Meld",
    nativeCurrency: {
      decimals: 18,
      name: "Meld",
      symbol: "MELD"
    },
    rpcUrls: {
      default: { http: ["https://rpc-1.meld.com"] }
    },
    blockExplorers: {
      default: { name: "MELDscan", url: "https://meldscan.io" }
    },
    contracts: {
      multicall3: {
        address: "0x769ee5a8e82c15c1b6e358f62ac8eb6e3abe8dc5",
        blockCreated: 360069
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId22 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId22]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId23 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId24 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morph.js
  var morph = /* @__PURE__ */ defineChain({
    id: 2818,
    name: "Morph",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.morphl2.io"],
        webSocket: ["wss://rpc.morphl2.io:8443"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Explorer",
        url: "https://explorer.morphl2.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId25 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId26 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId26]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId27 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId27]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId27]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId28 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId28]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId28]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId29 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId29]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId29]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId30 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId30]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId30
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId31 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId31]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId31]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId31]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId31,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId32 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId32
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId33 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId33,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId33]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId34 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId34]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId35 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId35]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saakuru.js
  var saakuru = /* @__PURE__ */ defineChain({
    id: 7225878,
    name: "Saakuru Mainnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.saakuru.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saakuru Explorer",
        url: "https://explorer.saakuru.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId36 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId36]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId36]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId36]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId37 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId38 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId39 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId39]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId40 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId40]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId40]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/that.js
  var that = /* @__PURE__ */ defineChain({
    id: 8428,
    name: "THAT Mainnet",
    nativeCurrency: { name: "THAT", symbol: "THAT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.thatchain.io/mainnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://that.blockscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/theta.js
  var theta = /* @__PURE__ */ defineChain({
    id: 361,
    name: "Theta Mainnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thetaTestnet.js
  var thetaTestnet = /* @__PURE__ */ defineChain({
    id: 365,
    name: "Theta Testnet",
    nativeCurrency: { name: "TFUEL", symbol: "TFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-api-testnet.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Theta Explorer",
        url: "https://testnet-explorer.thetatoken.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tomb.js
  var tomb = /* @__PURE__ */ defineChain({
    id: 6969,
    name: "Tomb Mainnet",
    nativeCurrency: { name: "TOMB", symbol: "TOMB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.tombchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tomb Explorer",
        url: "https://tombscout.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId41 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId41]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId42 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId43 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId43]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId43]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId43]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://testnet.xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zeniq.js
  var zeniq = /* @__PURE__ */ defineChain({
    id: 383414847825,
    name: "Zeniq Mainnet",
    nativeCurrency: { name: "ZENIQ", symbol: "ZENIQ", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zeniq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zeniq Explorer",
        url: "https://zeniqscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId44 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId44]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId44
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId45 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId45]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId45]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId45]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId46 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId46]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId46,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.40/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    enable() {
      return this.requestAccounts();
    }
    request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return Promise.resolve(this.getAccounts());
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, _callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'); ('(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.35";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId19 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId19]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId20 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId20]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId20]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId21 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId21]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId22 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId22]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId23 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId24 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId25 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId26 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId26]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId26]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId27 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId27]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId28 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId28]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId28]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId28]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId29 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId29]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId30 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId30]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId30,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId31 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId31
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId32 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId32,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId32]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId32]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId32]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId33 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId33]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId33
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId34 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId34]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId35 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId35]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId36 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId37 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId37]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId37]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId37]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId37]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId38 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId39 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId39]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId40 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId40]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId41 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId41]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId41]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId42 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "Blocksscan",
        url: "https://apothem.blocksscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId43 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId43]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId43]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId44 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId44]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId44,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId45 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId45]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    async enable() {
      return this.requestAccounts();
    }
    async request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return this.getAccounts();
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    async getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    async sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'); ('(() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js
  var version;
  var init_version = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/version.js"() {
      version = "1.0.6";
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js
  var BaseError;
  var init_errors = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/errors.js"() {
      init_version();
      BaseError = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
          const docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
            ...details ? [`Details: ${details}`] : [],
            `Version: abitype@${version}`
          ].join("\n");
          super(message);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "AbiTypeError"
          });
          if (args.cause)
            this.cause = args.cause;
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.shortMessage = shortMessage;
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js
  function execTyped(regex, string) {
    const match = regex.exec(string);
    return match?.groups;
  }
  var bytesRegex, integerRegex, isTupleRegex;
  var init_regex = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/regex.js"() {
      bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
      integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
      isTupleRegex = /^\(.+?\).*?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
  function formatAbiParameter(abiParameter) {
    let type = abiParameter.type;
    if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
      type = "(";
      const length = abiParameter.components.length;
      for (let i = 0; i < length; i++) {
        const component = abiParameter.components[i];
        type += formatAbiParameter(component);
        if (i < length - 1)
          type += ", ";
      }
      const result = execTyped(tupleRegex, abiParameter.type);
      type += `)${result?.array ?? ""}`;
      return formatAbiParameter({
        ...abiParameter,
        type
      });
    }
    if ("indexed" in abiParameter && abiParameter.indexed)
      type = `${type} indexed`;
    if (abiParameter.name)
      return `${type} ${abiParameter.name}`;
    return type;
  }
  var tupleRegex;
  var init_formatAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
      init_regex();
      tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
  function formatAbiParameters(abiParameters) {
    let params = "";
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      params += formatAbiParameter(abiParameter);
      if (i !== length - 1)
        params += ", ";
    }
    return params;
  }
  var init_formatAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
      init_formatAbiParameter();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
  function formatAbiItem(abiItem) {
    if (abiItem.type === "function")
      return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
    if (abiItem.type === "event")
      return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "error")
      return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
    if (abiItem.type === "constructor")
      return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
    if (abiItem.type === "fallback")
      return "fallback()";
    return "receive() external payable";
  }
  var init_formatAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
      init_formatAbiParameters();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
  function isErrorSignature(signature) {
    return errorSignatureRegex.test(signature);
  }
  function execErrorSignature(signature) {
    return execTyped(errorSignatureRegex, signature);
  }
  function isEventSignature(signature) {
    return eventSignatureRegex.test(signature);
  }
  function execEventSignature(signature) {
    return execTyped(eventSignatureRegex, signature);
  }
  function isFunctionSignature(signature) {
    return functionSignatureRegex.test(signature);
  }
  function execFunctionSignature(signature) {
    return execTyped(functionSignatureRegex, signature);
  }
  function isStructSignature(signature) {
    return structSignatureRegex.test(signature);
  }
  function execStructSignature(signature) {
    return execTyped(structSignatureRegex, signature);
  }
  function isConstructorSignature(signature) {
    return constructorSignatureRegex.test(signature);
  }
  function execConstructorSignature(signature) {
    return execTyped(constructorSignatureRegex, signature);
  }
  function isFallbackSignature(signature) {
    return fallbackSignatureRegex.test(signature);
  }
  function isReceiveSignature(signature) {
    return receiveSignatureRegex.test(signature);
  }
  var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
  var init_signatures = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
      init_regex();
      errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
      functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
      structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
      constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
      fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
      receiveSignatureRegex = /^receive\(\) external payable$/;
      modifiers = /* @__PURE__ */ new Set([
        "memory",
        "indexed",
        "storage",
        "calldata"
      ]);
      eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
      functionModifiers = /* @__PURE__ */ new Set([
        "calldata",
        "memory",
        "storage"
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
  var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
  var init_abiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
      init_errors();
      InvalidAbiItemError = class extends BaseError {
        constructor({ signature }) {
          super("Failed to parse ABI item.", {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: "/api/human#parseabiitem-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiItemError"
          });
        }
      };
      UnknownTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [
              `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownTypeError"
          });
        }
      };
      UnknownSolidityTypeError = class extends BaseError {
        constructor({ type }) {
          super("Unknown type.", {
            metaMessages: [`Type "${type}" is not a valid ABI type.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSolidityTypeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
  var InvalidAbiParameterError, InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
  var init_abiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
      init_errors();
      InvalidAbiParameterError = class extends BaseError {
        constructor({ param }) {
          super("Failed to parse ABI parameter.", {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: "/api/human#parseabiparameter-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParameterError"
          });
        }
      };
      InvalidAbiParametersError = class extends BaseError {
        constructor({ params }) {
          super("Failed to parse ABI parameters.", {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: "/api/human#parseabiparameters-1"
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiParametersError"
          });
        }
      };
      InvalidParameterError = class extends BaseError {
        constructor({ param }) {
          super("Invalid ABI parameter.", {
            details: param
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParameterError"
          });
        }
      };
      SolidityProtectedKeywordError = class extends BaseError {
        constructor({ param, name }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "SolidityProtectedKeywordError"
          });
        }
      };
      InvalidModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidModifierError"
          });
        }
      };
      InvalidFunctionModifierError = class extends BaseError {
        constructor({ param, type, modifier }) {
          super("Invalid ABI parameter.", {
            details: param,
            metaMessages: [
              `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
              `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
            ]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidFunctionModifierError"
          });
        }
      };
      InvalidAbiTypeParameterError = class extends BaseError {
        constructor({ abiParameter }) {
          super("Invalid ABI parameter.", {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ["ABI parameter type is invalid."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidAbiTypeParameterError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
  var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
  var init_signature = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
      init_errors();
      InvalidSignatureError = class extends BaseError {
        constructor({ signature, type }) {
          super(`Invalid ${type} signature.`, {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidSignatureError"
          });
        }
      };
      UnknownSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Unknown signature.", {
            details: signature
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "UnknownSignatureError"
          });
        }
      };
      InvalidStructSignatureError = class extends BaseError {
        constructor({ signature }) {
          super("Invalid struct signature.", {
            details: signature,
            metaMessages: ["No properties exist."]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidStructSignatureError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
  var CircularReferenceError;
  var init_struct = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
      init_errors();
      CircularReferenceError = class extends BaseError {
        constructor({ type }) {
          super("Circular reference detected.", {
            metaMessages: [`Struct "${type}" is a circular reference.`]
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "CircularReferenceError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
  var InvalidParenthesisError;
  var init_splitParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
      init_errors();
      InvalidParenthesisError = class extends BaseError {
        constructor({ current, depth }) {
          super("Unbalanced parentheses.", {
            metaMessages: [
              `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
            ],
            details: `Depth "${depth}"`
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "InvalidParenthesisError"
          });
        }
      };
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
  function getParameterCacheKey(param, type) {
    if (type)
      return `${type}:${param}`;
    return param;
  }
  var parameterCache;
  var init_cache = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
      parameterCache = /* @__PURE__ */ new Map([
        // Unnamed
        ["address", { type: "address" }],
        ["bool", { type: "bool" }],
        ["bytes", { type: "bytes" }],
        ["bytes32", { type: "bytes32" }],
        ["int", { type: "int256" }],
        ["int256", { type: "int256" }],
        ["string", { type: "string" }],
        ["uint", { type: "uint256" }],
        ["uint8", { type: "uint8" }],
        ["uint16", { type: "uint16" }],
        ["uint24", { type: "uint24" }],
        ["uint32", { type: "uint32" }],
        ["uint64", { type: "uint64" }],
        ["uint96", { type: "uint96" }],
        ["uint112", { type: "uint112" }],
        ["uint160", { type: "uint160" }],
        ["uint192", { type: "uint192" }],
        ["uint256", { type: "uint256" }],
        // Named
        ["address owner", { type: "address", name: "owner" }],
        ["address to", { type: "address", name: "to" }],
        ["bool approved", { type: "bool", name: "approved" }],
        ["bytes _data", { type: "bytes", name: "_data" }],
        ["bytes data", { type: "bytes", name: "data" }],
        ["bytes signature", { type: "bytes", name: "signature" }],
        ["bytes32 hash", { type: "bytes32", name: "hash" }],
        ["bytes32 r", { type: "bytes32", name: "r" }],
        ["bytes32 root", { type: "bytes32", name: "root" }],
        ["bytes32 s", { type: "bytes32", name: "s" }],
        ["string name", { type: "string", name: "name" }],
        ["string symbol", { type: "string", name: "symbol" }],
        ["string tokenURI", { type: "string", name: "tokenURI" }],
        ["uint tokenId", { type: "uint256", name: "tokenId" }],
        ["uint8 v", { type: "uint8", name: "v" }],
        ["uint256 balance", { type: "uint256", name: "balance" }],
        ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
        ["uint256 value", { type: "uint256", name: "value" }],
        // Indexed
        [
          "event:address indexed from",
          { type: "address", name: "from", indexed: true }
        ],
        ["event:address indexed to", { type: "address", name: "to", indexed: true }],
        [
          "event:uint indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ],
        [
          "event:uint256 indexed tokenId",
          { type: "uint256", name: "tokenId", indexed: true }
        ]
      ]);
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
  function parseSignature(signature, structs = {}) {
    if (isFunctionSignature(signature)) {
      const match = execFunctionSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "function" });
      const inputParams = splitParameters(match.parameters);
      const inputs = [];
      const inputLength = inputParams.length;
      for (let i = 0; i < inputLength; i++) {
        inputs.push(parseAbiParameter(inputParams[i], {
          modifiers: functionModifiers,
          structs,
          type: "function"
        }));
      }
      const outputs = [];
      if (match.returns) {
        const outputParams = splitParameters(match.returns);
        const outputLength = outputParams.length;
        for (let i = 0; i < outputLength; i++) {
          outputs.push(parseAbiParameter(outputParams[i], {
            modifiers: functionModifiers,
            structs,
            type: "function"
          }));
        }
      }
      return {
        name: match.name,
        type: "function",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs,
        outputs
      };
    }
    if (isEventSignature(signature)) {
      const match = execEventSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "event" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], {
          modifiers: eventModifiers,
          structs,
          type: "event"
        }));
      }
      return { name: match.name, type: "event", inputs: abiParameters };
    }
    if (isErrorSignature(signature)) {
      const match = execErrorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "error" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
      }
      return { name: match.name, type: "error", inputs: abiParameters };
    }
    if (isConstructorSignature(signature)) {
      const match = execConstructorSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "constructor" });
      const params = splitParameters(match.parameters);
      const abiParameters = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
      }
      return {
        type: "constructor",
        stateMutability: match.stateMutability ?? "nonpayable",
        inputs: abiParameters
      };
    }
    if (isFallbackSignature(signature))
      return { type: "fallback" };
    if (isReceiveSignature(signature))
      return {
        type: "receive",
        stateMutability: "payable"
      };
    throw new UnknownSignatureError({ signature });
  }
  function parseAbiParameter(param, options) {
    const parameterCacheKey = getParameterCacheKey(param, options?.type);
    if (parameterCache.has(parameterCacheKey))
      return parameterCache.get(parameterCacheKey);
    const isTuple = isTupleRegex.test(param);
    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
    if (!match)
      throw new InvalidParameterError({ param });
    if (match.name && isSolidityKeyword(match.name))
      throw new SolidityProtectedKeywordError({ param, name: match.name });
    const name = match.name ? { name: match.name } : {};
    const indexed = match.modifier === "indexed" ? { indexed: true } : {};
    const structs = options?.structs ?? {};
    let type;
    let components = {};
    if (isTuple) {
      type = "tuple";
      const params = splitParameters(match.type);
      const components_ = [];
      const length = params.length;
      for (let i = 0; i < length; i++) {
        components_.push(parseAbiParameter(params[i], { structs }));
      }
      components = { components: components_ };
    } else if (match.type in structs) {
      type = "tuple";
      components = { components: structs[match.type] };
    } else if (dynamicIntegerRegex.test(match.type)) {
      type = `${match.type}256`;
    } else {
      type = match.type;
      if (!(options?.type === "struct") && !isSolidityType(type))
        throw new UnknownSolidityTypeError({ type });
    }
    if (match.modifier) {
      if (!options?.modifiers?.has?.(match.modifier))
        throw new InvalidModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
      if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
        throw new InvalidFunctionModifierError({
          param,
          type: options?.type,
          modifier: match.modifier
        });
    }
    const abiParameter = {
      type: `${type}${match.array ?? ""}`,
      ...name,
      ...indexed,
      ...components
    };
    parameterCache.set(parameterCacheKey, abiParameter);
    return abiParameter;
  }
  function splitParameters(params, result = [], current = "", depth = 0) {
    const length = params.trim().length;
    for (let i = 0; i < length; i++) {
      const char = params[i];
      const tail = params.slice(i + 1);
      switch (char) {
        case ",":
          return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
        case "(":
          return splitParameters(tail, result, `${current}${char}`, depth + 1);
        case ")":
          return splitParameters(tail, result, `${current}${char}`, depth - 1);
        default:
          return splitParameters(tail, result, `${current}${char}`, depth);
      }
    }
    if (current === "")
      return result;
    if (depth !== 0)
      throw new InvalidParenthesisError({ current, depth });
    result.push(current.trim());
    return result;
  }
  function isSolidityType(type) {
    return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
  }
  function isSolidityKeyword(name) {
    return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
  }
  function isValidDataLocation(type, isArray) {
    return isArray || type === "bytes" || type === "string" || type === "tuple";
  }
  var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
  var init_utils = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_cache();
      init_signatures();
      abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
      dynamicIntegerRegex = /^u?int$/;
      protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
  function parseStructs(signatures) {
    const shallowStructs = {};
    const signaturesLength = signatures.length;
    for (let i = 0; i < signaturesLength; i++) {
      const signature = signatures[i];
      if (!isStructSignature(signature))
        continue;
      const match = execStructSignature(signature);
      if (!match)
        throw new InvalidSignatureError({ signature, type: "struct" });
      const properties = match.properties.split(";");
      const components = [];
      const propertiesLength = properties.length;
      for (let k = 0; k < propertiesLength; k++) {
        const property = properties[k];
        const trimmed = property.trim();
        if (!trimmed)
          continue;
        const abiParameter = parseAbiParameter(trimmed, {
          type: "struct"
        });
        components.push(abiParameter);
      }
      if (!components.length)
        throw new InvalidStructSignatureError({ signature });
      shallowStructs[match.name] = components;
    }
    const resolvedStructs = {};
    const entries = Object.entries(shallowStructs);
    const entriesLength = entries.length;
    for (let i = 0; i < entriesLength; i++) {
      const [name, parameters] = entries[i];
      resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
    }
    return resolvedStructs;
  }
  function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
    const components = [];
    const length = abiParameters.length;
    for (let i = 0; i < length; i++) {
      const abiParameter = abiParameters[i];
      const isTuple = isTupleRegex.test(abiParameter.type);
      if (isTuple)
        components.push(abiParameter);
      else {
        const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
        if (!match?.type)
          throw new InvalidAbiTypeParameterError({ abiParameter });
        const { array, type } = match;
        if (type in structs) {
          if (ancestors.has(type))
            throw new CircularReferenceError({ type });
          components.push({
            ...abiParameter,
            type: `tuple${array ?? ""}`,
            components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
          });
        } else {
          if (isSolidityType(type))
            components.push(abiParameter);
          else
            throw new UnknownTypeError({ type });
        }
      }
    }
    return components;
  }
  var typeWithoutTupleRegex;
  var init_structs = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
      init_regex();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_struct();
      init_signatures();
      init_utils();
      typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
  function parseAbi(signatures) {
    const structs = parseStructs(signatures);
    const abi2 = [];
    const length = signatures.length;
    for (let i = 0; i < length; i++) {
      const signature = signatures[i];
      if (isStructSignature(signature))
        continue;
      abi2.push(parseSignature(signature, structs));
    }
    return abi2;
  }
  var init_parseAbi = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
  function parseAbiItem(signature) {
    let abiItem;
    if (typeof signature === "string")
      abiItem = parseSignature(signature);
    else {
      const structs = parseStructs(signature);
      const length = signature.length;
      for (let i = 0; i < length; i++) {
        const signature_ = signature[i];
        if (isStructSignature(signature_))
          continue;
        abiItem = parseSignature(signature_, structs);
        break;
      }
    }
    if (!abiItem)
      throw new InvalidAbiItemError({ signature });
    return abiItem;
  }
  var init_parseAbiItem = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
      init_abiItem();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js
  function parseAbiParameter2(param) {
    let abiParameter;
    if (typeof param === "string")
      abiParameter = parseAbiParameter(param, {
        modifiers
      });
    else {
      const structs = parseStructs(param);
      const length = param.length;
      for (let i = 0; i < length; i++) {
        const signature = param[i];
        if (isStructSignature(signature))
          continue;
        abiParameter = parseAbiParameter(signature, { modifiers, structs });
        break;
      }
    }
    if (!abiParameter)
      throw new InvalidAbiParameterError({ param });
    return abiParameter;
  }
  var init_parseAbiParameter = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameter.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
  function parseAbiParameters(params) {
    const abiParameters = [];
    if (typeof params === "string") {
      const parameters = splitParameters(params);
      const length = parameters.length;
      for (let i = 0; i < length; i++) {
        abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
      }
    } else {
      const structs = parseStructs(params);
      const length = params.length;
      for (let i = 0; i < length; i++) {
        const signature = params[i];
        if (isStructSignature(signature))
          continue;
        const parameters = splitParameters(signature);
        const length2 = parameters.length;
        for (let k = 0; k < length2; k++) {
          abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
        }
      }
    }
    if (abiParameters.length === 0)
      throw new InvalidAbiParametersError({ params });
    return abiParameters;
  }
  var init_parseAbiParameters = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
      init_abiParameter();
      init_signatures();
      init_structs();
      init_utils();
      init_utils();
    }
  });

  // node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js
  var init_exports = __esm({
    "node_modules/.deno/abitype@1.0.6/node_modules/abitype/dist/esm/exports/index.js"() {
      init_formatAbiItem();
      init_parseAbi();
      init_parseAbiItem();
      init_parseAbiParameter();
      init_parseAbiParameters();
      init_abiItem();
      init_abiParameter();
      init_signature();
      init_splitParameters();
      init_struct();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js
  function formatAbiItem2(abiItem, { includeName = false } = {}) {
    if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
      throw new InvalidDefinitionTypeError(abiItem.type);
    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
  }
  function formatAbiParams(params, { includeName = false } = {}) {
    if (!params)
      return "";
    return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
  }
  function formatAbiParam(param, { includeName }) {
    if (param.type.startsWith("tuple")) {
      return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
    }
    return param.type + (includeName && param.name ? ` ${param.name}` : "");
  }
  var init_formatAbiItem2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
      init_abi();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js
  function isHex(value, { strict = true } = {}) {
    if (!value)
      return false;
    if (typeof value !== "string")
      return false;
    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
  }
  var init_isHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isHex.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js
  function size(value) {
    if (isHex(value, { strict: false }))
      return Math.ceil((value.length - 2) / 2);
    return value.length;
  }
  var init_size = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/size.js"() {
      init_isHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js
  var version2;
  var init_version2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/version.js"() {
      version2 = "2.21.35";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js
  function setErrorConfig(config) {
    errorConfig = config;
  }
  function walk(err, fn) {
    if (fn?.(err))
      return err;
    if (err && typeof err === "object" && "cause" in err)
      return walk(err.cause, fn);
    return fn ? null : err;
  }
  var errorConfig, BaseError2;
  var init_base = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/base.js"() {
      init_version2();
      errorConfig = {
        getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
        version: `viem@${version2}`
      };
      BaseError2 = class _BaseError extends Error {
        constructor(shortMessage, args = {}) {
          const details = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.details;
            if (args.cause?.message)
              return args.cause.message;
            return args.details;
          })();
          const docsPath9 = (() => {
            if (args.cause instanceof _BaseError)
              return args.cause.docsPath || args.docsPath;
            return args.docsPath;
          })();
          const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath9 });
          const message = [
            shortMessage || "An error occurred.",
            "",
            ...args.metaMessages ? [...args.metaMessages, ""] : [],
            ...docsUrl ? [`Docs: ${docsUrl}`] : [],
            ...details ? [`Details: ${details}`] : [],
            ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
          ].join("\n");
          super(message, args.cause ? { cause: args.cause } : void 0);
          Object.defineProperty(this, "details", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "docsPath", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "metaMessages", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "shortMessage", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "version", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "BaseError"
          });
          this.details = details;
          this.docsPath = docsPath9;
          this.metaMessages = args.metaMessages;
          this.name = args.name ?? this.name;
          this.shortMessage = shortMessage;
          this.version = version2;
        }
        walk(fn) {
          return walk(this, fn);
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js
  var AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, AbiDecodingDataSizeInvalidError, AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiErrorInputsNotFoundError, AbiErrorNotFoundError, AbiErrorSignatureNotFoundError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, AbiEventNotFoundError, AbiFunctionNotFoundError, AbiFunctionOutputsNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, BytesSizeMismatchError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError, UnsupportedPackedAbiType;
  var init_abi = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/abi.js"() {
      init_formatAbiItem2();
      init_size();
      init_base();
      AbiConstructorNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "A constructor was not found on the ABI.",
            "Make sure you are using the correct ABI and that the constructor exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorNotFoundError"
          });
        }
      };
      AbiConstructorParamsNotFoundError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super([
            "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
            "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiConstructorParamsNotFoundError"
          });
        }
      };
      AbiDecodingDataSizeInvalidError = class extends BaseError2 {
        constructor({ data, size: size3 }) {
          super([
            `Data size of ${size3} bytes is invalid.`,
            "Size must be in increments of 32 bytes (size % 32 === 0)."
          ].join("\n"), {
            metaMessages: [`Data: ${data} (${size3} bytes)`],
            name: "AbiDecodingDataSizeInvalidError"
          });
        }
      };
      AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
        constructor({ data, params, size: size3 }) {
          super([`Data size of ${size3} bytes is too small for given parameters.`].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "AbiDecodingDataSizeTooSmallError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      AbiDecodingZeroDataError = class extends BaseError2 {
        constructor() {
          super('Cannot decode zero data ("0x") with ABI parameters.', {
            name: "AbiDecodingZeroDataError"
          });
        }
      };
      AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength, type }) {
          super([
            `ABI encoding array length mismatch for type ${type}.`,
            `Expected length: ${expectedLength}`,
            `Given length: ${givenLength}`
          ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
        }
      };
      AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, value }) {
          super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
        }
      };
      AbiEncodingLengthMismatchError = class extends BaseError2 {
        constructor({ expectedLength, givenLength }) {
          super([
            "ABI encoding params/values length mismatch.",
            `Expected length (params): ${expectedLength}`,
            `Given length (values): ${givenLength}`
          ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
        }
      };
      AbiErrorInputsNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 }) {
          super([
            `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
            "Cannot encode error result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the inputs exist on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorInputsNotFoundError"
          });
        }
      };
      AbiErrorNotFoundError = class extends BaseError2 {
        constructor(errorName, { docsPath: docsPath9 } = {}) {
          super([
            `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorNotFoundError"
          });
        }
      };
      AbiErrorSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded error signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the error exists on it.",
            `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiErrorSignatureNotFoundError"
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.signature = signature;
        }
      };
      AbiEventSignatureEmptyTopicsError = class extends BaseError2 {
        constructor({ docsPath: docsPath9 }) {
          super("Cannot extract event signature from empty topics.", {
            docsPath: docsPath9,
            name: "AbiEventSignatureEmptyTopicsError"
          });
        }
      };
      AbiEventSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded event signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventSignatureNotFoundError"
          });
        }
      };
      AbiEventNotFoundError = class extends BaseError2 {
        constructor(eventName, { docsPath: docsPath9 } = {}) {
          super([
            `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the event exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiEventNotFoundError"
          });
        }
      };
      AbiFunctionNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 } = {}) {
          super([
            `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionNotFoundError"
          });
        }
      };
      AbiFunctionOutputsNotFoundError = class extends BaseError2 {
        constructor(functionName, { docsPath: docsPath9 }) {
          super([
            `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
            "Cannot decode function result without knowing what the parameter types are.",
            "Make sure you are using the correct ABI and that the function exists on it."
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionOutputsNotFoundError"
          });
        }
      };
      AbiFunctionSignatureNotFoundError = class extends BaseError2 {
        constructor(signature, { docsPath: docsPath9 }) {
          super([
            `Encoded function signature "${signature}" not found on ABI.`,
            "Make sure you are using the correct ABI and that the function exists on it.",
            `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
          ].join("\n"), {
            docsPath: docsPath9,
            name: "AbiFunctionSignatureNotFoundError"
          });
        }
      };
      AbiItemAmbiguityError = class extends BaseError2 {
        constructor(x, y) {
          super("Found ambiguous types in overloaded ABI items.", {
            metaMessages: [
              `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
              `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
              "",
              "These types encode differently and cannot be distinguished at runtime.",
              "Remove one of the ambiguous items in the ABI."
            ],
            name: "AbiItemAmbiguityError"
          });
        }
      };
      BytesSizeMismatchError = class extends BaseError2 {
        constructor({ expectedSize, givenSize }) {
          super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
            name: "BytesSizeMismatchError"
          });
        }
      };
      DecodeLogDataMismatch = class extends BaseError2 {
        constructor({ abiItem, data, params, size: size3 }) {
          super([
            `Data size of ${size3} bytes is too small for non-indexed event parameters.`
          ].join("\n"), {
            metaMessages: [
              `Params: (${formatAbiParams(params, { includeName: true })})`,
              `Data:   ${data} (${size3} bytes)`
            ],
            name: "DecodeLogDataMismatch"
          });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "params", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "size", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
          this.data = data;
          this.params = params;
          this.size = size3;
        }
      };
      DecodeLogTopicsMismatch = class extends BaseError2 {
        constructor({ abiItem, param }) {
          super([
            `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem2(abiItem, { includeName: true })}".`
          ].join("\n"), { name: "DecodeLogTopicsMismatch" });
          Object.defineProperty(this, "abiItem", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abiItem = abiItem;
        }
      };
      InvalidAbiEncodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid encoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
        }
      };
      InvalidAbiDecodingTypeError = class extends BaseError2 {
        constructor(type, { docsPath: docsPath9 }) {
          super([
            `Type "${type}" is not a valid decoding type.`,
            "Please provide a valid ABI type."
          ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
        }
      };
      InvalidArrayError = class extends BaseError2 {
        constructor(value) {
          super([`Value "${value}" is not a valid array.`].join("\n"), {
            name: "InvalidArrayError"
          });
        }
      };
      InvalidDefinitionTypeError = class extends BaseError2 {
        constructor(type) {
          super([
            `"${type}" is not a valid definition type.`,
            'Valid types: "function", "event", "error"'
          ].join("\n"), { name: "InvalidDefinitionTypeError" });
        }
      };
      UnsupportedPackedAbiType = class extends BaseError2 {
        constructor(type) {
          super(`Type "${type}" is not supported for packed encoding.`, {
            name: "UnsupportedPackedAbiType"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js
  var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError, InvalidBytesLengthError;
  var init_data = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/data.js"() {
      init_base();
      SliceOffsetOutOfBoundsError = class extends BaseError2 {
        constructor({ offset, position, size: size3 }) {
          super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
        }
      };
      SizeExceedsPaddingSizeError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
        }
      };
      InvalidBytesLengthError = class extends BaseError2 {
        constructor({ size: size3, targetSize, type }) {
          super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size3} ${type} long.`, { name: "InvalidBytesLengthError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js
  function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
    if (typeof hexOrBytes === "string")
      return padHex(hexOrBytes, { dir, size: size3 });
    return padBytes(hexOrBytes, { dir, size: size3 });
  }
  function padHex(hex_, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return hex_;
    const hex = hex_.replace("0x", "");
    if (hex.length > size3 * 2)
      throw new SizeExceedsPaddingSizeError({
        size: Math.ceil(hex.length / 2),
        targetSize: size3,
        type: "hex"
      });
    return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
  }
  function padBytes(bytes2, { dir, size: size3 = 32 } = {}) {
    if (size3 === null)
      return bytes2;
    if (bytes2.length > size3)
      throw new SizeExceedsPaddingSizeError({
        size: bytes2.length,
        targetSize: size3,
        type: "bytes"
      });
    const paddedBytes = new Uint8Array(size3);
    for (let i = 0; i < size3; i++) {
      const padEnd = dir === "right";
      paddedBytes[padEnd ? i : size3 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
    }
    return paddedBytes;
  }
  var init_pad = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/pad.js"() {
      init_data();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js
  var IntegerOutOfRangeError, InvalidBytesBooleanError, InvalidHexBooleanError, InvalidHexValueError, SizeOverflowError;
  var init_encoding = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/encoding.js"() {
      init_base();
      IntegerOutOfRangeError = class extends BaseError2 {
        constructor({ max, min, signed, size: size3, value }) {
          super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
        }
      };
      InvalidBytesBooleanError = class extends BaseError2 {
        constructor(bytes2) {
          super(`Bytes value "${bytes2}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
            name: "InvalidBytesBooleanError"
          });
        }
      };
      InvalidHexBooleanError = class extends BaseError2 {
        constructor(hex) {
          super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
        }
      };
      InvalidHexValueError = class extends BaseError2 {
        constructor(value) {
          super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
        }
      };
      SizeOverflowError = class extends BaseError2 {
        constructor({ givenSize, maxSize }) {
          super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js
  function trim(hexOrBytes, { dir = "left" } = {}) {
    let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
    let sliceLength = 0;
    for (let i = 0; i < data.length - 1; i++) {
      if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
        sliceLength++;
      else
        break;
    }
    data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
    if (typeof hexOrBytes === "string") {
      if (data.length === 1 && dir === "right")
        data = `${data}0`;
      return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
    }
    return data;
  }
  var init_trim = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/trim.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js
  function assertSize(hexOrBytes, { size: size3 }) {
    if (size(hexOrBytes) > size3)
      throw new SizeOverflowError({
        givenSize: size(hexOrBytes),
        maxSize: size3
      });
  }
  function fromHex(hex, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return hexToNumber(hex, opts);
    if (to === "bigint")
      return hexToBigInt(hex, opts);
    if (to === "string")
      return hexToString(hex, opts);
    if (to === "boolean")
      return hexToBool(hex, opts);
    return hexToBytes(hex, opts);
  }
  function hexToBigInt(hex, opts = {}) {
    const { signed } = opts;
    if (opts.size)
      assertSize(hex, { size: opts.size });
    const value = BigInt(hex);
    if (!signed)
      return value;
    const size3 = (hex.length - 2) / 2;
    const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
    if (value <= max)
      return value;
    return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
  }
  function hexToBool(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = trim(hex);
    }
    if (trim(hex) === "0x00")
      return false;
    if (trim(hex) === "0x01")
      return true;
    throw new InvalidHexBooleanError(hex);
  }
  function hexToNumber(hex, opts = {}) {
    return Number(hexToBigInt(hex, opts));
  }
  function hexToString(hex, opts = {}) {
    let bytes2 = hexToBytes(hex);
    if (opts.size) {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
      init_encoding();
      init_size();
      init_trim();
      init_toBytes();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js
  function toHex(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToHex(value, opts);
    if (typeof value === "string") {
      return stringToHex(value, opts);
    }
    if (typeof value === "boolean")
      return boolToHex(value, opts);
    return bytesToHex(value, opts);
  }
  function boolToHex(value, opts = {}) {
    const hex = `0x${Number(value)}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { size: opts.size });
    }
    return hex;
  }
  function bytesToHex(value, opts = {}) {
    let string = "";
    for (let i = 0; i < value.length; i++) {
      string += hexes[value[i]];
    }
    const hex = `0x${string}`;
    if (typeof opts.size === "number") {
      assertSize(hex, { size: opts.size });
      return pad(hex, { dir: "right", size: opts.size });
    }
    return hex;
  }
  function numberToHex(value_, opts = {}) {
    const { signed, size: size3 } = opts;
    const value = BigInt(value_);
    let maxValue;
    if (size3) {
      if (signed)
        maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
      else
        maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
    } else if (typeof value_ === "number") {
      maxValue = BigInt(Number.MAX_SAFE_INTEGER);
    }
    const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
    if (maxValue && value > maxValue || value < minValue) {
      const suffix = typeof value_ === "bigint" ? "n" : "";
      throw new IntegerOutOfRangeError({
        max: maxValue ? `${maxValue}${suffix}` : void 0,
        min: `${minValue}${suffix}`,
        signed,
        size: size3,
        value: `${value_}${suffix}`
      });
    }
    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
    if (size3)
      return pad(hex, { size: size3 });
    return hex;
  }
  function stringToHex(value_, opts = {}) {
    const value = encoder.encode(value_);
    return bytesToHex(value, opts);
  }
  var hexes, encoder;
  var init_toHex = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toHex.js"() {
      init_encoding();
      init_pad();
      init_fromHex();
      hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
      encoder = /* @__PURE__ */ new TextEncoder();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js
  function toBytes(value, opts = {}) {
    if (typeof value === "number" || typeof value === "bigint")
      return numberToBytes(value, opts);
    if (typeof value === "boolean")
      return boolToBytes(value, opts);
    if (isHex(value))
      return hexToBytes(value, opts);
    return stringToBytes(value, opts);
  }
  function boolToBytes(value, opts = {}) {
    const bytes2 = new Uint8Array(1);
    bytes2[0] = Number(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { size: opts.size });
    }
    return bytes2;
  }
  function charCodeToBase16(char) {
    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
      return char - charCodeMap.zero;
    if (char >= charCodeMap.A && char <= charCodeMap.F)
      return char - (charCodeMap.A - 10);
    if (char >= charCodeMap.a && char <= charCodeMap.f)
      return char - (charCodeMap.a - 10);
    return void 0;
  }
  function hexToBytes(hex_, opts = {}) {
    let hex = hex_;
    if (opts.size) {
      assertSize(hex, { size: opts.size });
      hex = pad(hex, { dir: "right", size: opts.size });
    }
    let hexString = hex.slice(2);
    if (hexString.length % 2)
      hexString = `0${hexString}`;
    const length = hexString.length / 2;
    const bytes2 = new Uint8Array(length);
    for (let index2 = 0, j = 0; index2 < length; index2++) {
      const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
      const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
      if (nibbleLeft === void 0 || nibbleRight === void 0) {
        throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
      }
      bytes2[index2] = nibbleLeft * 16 + nibbleRight;
    }
    return bytes2;
  }
  function numberToBytes(value, opts) {
    const hex = numberToHex(value, opts);
    return hexToBytes(hex);
  }
  function stringToBytes(value, opts = {}) {
    const bytes2 = encoder2.encode(value);
    if (typeof opts.size === "number") {
      assertSize(bytes2, { size: opts.size });
      return pad(bytes2, { dir: "right", size: opts.size });
    }
    return bytes2;
  }
  var encoder2, charCodeMap;
  var init_toBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
      init_base();
      init_isHex();
      init_pad();
      init_fromHex();
      init_toHex();
      encoder2 = /* @__PURE__ */ new TextEncoder();
      charCodeMap = {
        zero: 48,
        nine: 57,
        A: 65,
        F: 70,
        a: 97,
        f: 102
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
  function number(n) {
    if (!Number.isSafeInteger(n) || n < 0)
      throw new Error(`positive integer expected, not ${n}`);
  }
  function isBytes(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function bytes(b, ...lengths) {
    if (!isBytes(b))
      throw new Error("Uint8Array expected");
    if (lengths.length > 0 && !lengths.includes(b.length))
      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
  }
  function hash(h) {
    if (typeof h !== "function" || typeof h.create !== "function")
      throw new Error("Hash should be wrapped by utils.wrapConstructor");
    number(h.outputLen);
    number(h.blockLen);
  }
  function exists(instance, checkFinished = true) {
    if (instance.destroyed)
      throw new Error("Hash instance has been destroyed");
    if (checkFinished && instance.finished)
      throw new Error("Hash#digest() has already been called");
  }
  function output(out, instance) {
    bytes(out);
    const min = instance.outputLen;
    if (out.length < min) {
      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
    }
  }
  var init_assert = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js"() {
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
  function fromBig(n, le = false) {
    if (le)
      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
  }
  function split(lst, le = false) {
    let Ah = new Uint32Array(lst.length);
    let Al = new Uint32Array(lst.length);
    for (let i = 0; i < lst.length; i++) {
      const { h, l } = fromBig(lst[i], le);
      [Ah[i], Al[i]] = [h, l];
    }
    return [Ah, Al];
  }
  var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
  var init_u64 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js"() {
      U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
      _32n = /* @__PURE__ */ BigInt(32);
      rotlSH = (h, l, s) => h << s | l >>> 32 - s;
      rotlSL = (h, l, s) => l << s | h >>> 32 - s;
      rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
      rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js
  var crypto;
  var init_crypto = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/crypto.js"() {
      crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
  function byteSwap32(arr) {
    for (let i = 0; i < arr.length; i++) {
      arr[i] = byteSwap(arr[i]);
    }
  }
  function utf8ToBytes(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function toBytes2(data) {
    if (typeof data === "string")
      data = utf8ToBytes(data);
    bytes(data);
    return data;
  }
  function concatBytes(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      bytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function wrapConstructor(hashCons) {
    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
    const tmp = hashCons();
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = () => hashCons();
    return hashC;
  }
  function wrapXOFConstructorWithOpts(hashCons) {
    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
    const tmp = hashCons({});
    hashC.outputLen = tmp.outputLen;
    hashC.blockLen = tmp.blockLen;
    hashC.create = (opts) => hashCons(opts);
    return hashC;
  }
  function randomBytes(bytesLength = 32) {
    if (crypto && typeof crypto.getRandomValues === "function") {
      return crypto.getRandomValues(new Uint8Array(bytesLength));
    }
    if (crypto && typeof crypto.randomBytes === "function") {
      return crypto.randomBytes(bytesLength);
    }
    throw new Error("crypto.getRandomValues must be defined");
  }
  var u32, createView, rotr, rotl, isLE, byteSwap, Hash, toStr;
  var init_utils2 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js"() {
      init_crypto();
      init_assert();
      u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
      createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
      rotr = (word, shift) => word << 32 - shift | word >>> shift;
      rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
      isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
      byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
      Hash = class {
        // Safe version that clones internal state
        clone() {
          return this._cloneInto();
        }
      };
      toStr = {}.toString;
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
  function keccakP(s, rounds = 24) {
    const B = new Uint32Array(5 * 2);
    for (let round = 24 - rounds; round < 24; round++) {
      for (let x = 0; x < 10; x++)
        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
      for (let x = 0; x < 10; x += 2) {
        const idx1 = (x + 8) % 10;
        const idx0 = (x + 2) % 10;
        const B0 = B[idx0];
        const B1 = B[idx0 + 1];
        const Th = rotlH(B0, B1, 1) ^ B[idx1];
        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
        for (let y = 0; y < 50; y += 10) {
          s[x + y] ^= Th;
          s[x + y + 1] ^= Tl;
        }
      }
      let curH = s[2];
      let curL = s[3];
      for (let t = 0; t < 24; t++) {
        const shift = SHA3_ROTL[t];
        const Th = rotlH(curH, curL, shift);
        const Tl = rotlL(curH, curL, shift);
        const PI = SHA3_PI[t];
        curH = s[PI];
        curL = s[PI + 1];
        s[PI] = Th;
        s[PI + 1] = Tl;
      }
      for (let y = 0; y < 50; y += 10) {
        for (let x = 0; x < 10; x++)
          B[x] = s[y + x];
        for (let x = 0; x < 10; x++)
          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
      }
      s[0] ^= SHA3_IOTA_H[round];
      s[1] ^= SHA3_IOTA_L[round];
    }
    B.fill(0);
  }
  var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
  var init_sha3 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js"() {
      init_assert();
      init_u64();
      init_utils2();
      SHA3_PI = [];
      SHA3_ROTL = [];
      _SHA3_IOTA = [];
      _0n = /* @__PURE__ */ BigInt(0);
      _1n = /* @__PURE__ */ BigInt(1);
      _2n = /* @__PURE__ */ BigInt(2);
      _7n = /* @__PURE__ */ BigInt(7);
      _256n = /* @__PURE__ */ BigInt(256);
      _0x71n = /* @__PURE__ */ BigInt(113);
      for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
        [x, y] = [y, (2 * x + 3 * y) % 5];
        SHA3_PI.push(2 * (5 * y + x));
        SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
        let t = _0n;
        for (let j = 0; j < 7; j++) {
          R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
          if (R & _2n)
            t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
        }
        _SHA3_IOTA.push(t);
      }
      [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
      rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
      rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
      Keccak = class _Keccak extends Hash {
        // NOTE: we accept arguments in bytes instead of bits here.
        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
          super();
          this.blockLen = blockLen;
          this.suffix = suffix;
          this.outputLen = outputLen;
          this.enableXOF = enableXOF;
          this.rounds = rounds;
          this.pos = 0;
          this.posOut = 0;
          this.finished = false;
          this.destroyed = false;
          number(outputLen);
          if (0 >= this.blockLen || this.blockLen >= 200)
            throw new Error("Sha3 supports only keccak-f1600 function");
          this.state = new Uint8Array(200);
          this.state32 = u32(this.state);
        }
        keccak() {
          if (!isLE)
            byteSwap32(this.state32);
          keccakP(this.state32, this.rounds);
          if (!isLE)
            byteSwap32(this.state32);
          this.posOut = 0;
          this.pos = 0;
        }
        update(data) {
          exists(this);
          const { blockLen, state } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            for (let i = 0; i < take; i++)
              state[this.pos++] ^= data[pos++];
            if (this.pos === blockLen)
              this.keccak();
          }
          return this;
        }
        finish() {
          if (this.finished)
            return;
          this.finished = true;
          const { state, suffix, pos, blockLen } = this;
          state[pos] ^= suffix;
          if ((suffix & 128) !== 0 && pos === blockLen - 1)
            this.keccak();
          state[blockLen - 1] ^= 128;
          this.keccak();
        }
        writeInto(out) {
          exists(this, false);
          bytes(out);
          this.finish();
          const bufferOut = this.state;
          const { blockLen } = this;
          for (let pos = 0, len = out.length; pos < len; ) {
            if (this.posOut >= blockLen)
              this.keccak();
            const take = Math.min(blockLen - this.posOut, len - pos);
            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
            this.posOut += take;
            pos += take;
          }
          return out;
        }
        xofInto(out) {
          if (!this.enableXOF)
            throw new Error("XOF is not possible for this instance");
          return this.writeInto(out);
        }
        xof(bytes2) {
          number(bytes2);
          return this.xofInto(new Uint8Array(bytes2));
        }
        digestInto(out) {
          output(out, this);
          if (this.finished)
            throw new Error("digest() was already called");
          this.writeInto(out);
          this.destroy();
          return out;
        }
        digest() {
          return this.digestInto(new Uint8Array(this.outputLen));
        }
        destroy() {
          this.destroyed = true;
          this.state.fill(0);
        }
        _cloneInto(to) {
          const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
          to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
          to.state32.set(this.state32);
          to.pos = this.pos;
          to.posOut = this.posOut;
          to.finished = this.finished;
          to.rounds = rounds;
          to.suffix = suffix;
          to.outputLen = outputLen;
          to.enableXOF = enableXOF;
          to.destroyed = this.destroyed;
          return to;
        }
      };
      gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
      sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
      sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
      sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
      sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
      keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
      keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
      keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
      keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
      genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
      shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
      shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js
  function keccak256(value, to_) {
    const to = to_ || "hex";
    const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }
  var init_keccak256 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/keccak256.js"() {
      init_sha3();
      init_isHex();
      init_toBytes();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js
  function hashSignature(sig) {
    return hash2(sig);
  }
  var hash2;
  var init_hashSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/hashSignature.js"() {
      init_toBytes();
      init_keccak256();
      hash2 = (value) => keccak256(toBytes(value));
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js
  function normalizeSignature(signature) {
    let active = true;
    let current = "";
    let level = 0;
    let result = "";
    let valid = false;
    for (let i = 0; i < signature.length; i++) {
      const char = signature[i];
      if (["(", ")", ","].includes(char))
        active = true;
      if (char === "(")
        level++;
      if (char === ")")
        level--;
      if (!active)
        continue;
      if (level === 0) {
        if (char === " " && ["event", "function", ""].includes(result))
          result = "";
        else {
          result += char;
          if (char === ")") {
            valid = true;
            break;
          }
        }
        continue;
      }
      if (char === " ") {
        if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
          current = "";
          active = false;
        }
        continue;
      }
      result += char;
      current += char;
    }
    if (!valid)
      throw new BaseError2("Unable to normalize signature.");
    return result;
  }
  var init_normalizeSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
      init_base();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js
  var toSignature;
  var init_toSignature = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignature.js"() {
      init_exports();
      init_normalizeSignature();
      toSignature = (def) => {
        const def_ = (() => {
          if (typeof def === "string")
            return def;
          return formatAbiItem(def);
        })();
        return normalizeSignature(def_);
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js
  function toSignatureHash(fn) {
    return hashSignature(toSignature(fn));
  }
  var init_toSignatureHash = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
      init_hashSignature();
      init_toSignature();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js
  var toEventSelector;
  var init_toEventSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
      init_toSignatureHash();
      toEventSelector = toSignatureHash;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js
  var InvalidAddressError;
  var init_address = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/address.js"() {
      init_base();
      InvalidAddressError = class extends BaseError2 {
        constructor({ address }) {
          super(`Address "${address}" is invalid.`, {
            metaMessages: [
              "- Address must be a hex value of 20 bytes (40 hex characters).",
              "- Address must match its checksum counterpart."
            ],
            name: "InvalidAddressError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js
  var LruMap;
  var init_lru = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/lru.js"() {
      LruMap = class extends Map {
        constructor(size3) {
          super();
          Object.defineProperty(this, "maxSize", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.maxSize = size3;
        }
        get(key) {
          const value = super.get(key);
          if (super.has(key) && value !== void 0) {
            this.delete(key);
            super.set(key, value);
          }
          return value;
        }
        set(key, value) {
          super.set(key, value);
          if (this.maxSize && this.size > this.maxSize) {
            const firstKey = this.keys().next().value;
            if (firstKey)
              this.delete(firstKey);
          }
          return this;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js
  function checksumAddress(address_, chainId) {
    if (checksumAddressCache.has(`${address_}.${chainId}`))
      return checksumAddressCache.get(`${address_}.${chainId}`);
    const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
    const hash3 = keccak256(stringToBytes(hexAddress), "bytes");
    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
    for (let i = 0; i < 40; i += 2) {
      if (hash3[i >> 1] >> 4 >= 8 && address[i]) {
        address[i] = address[i].toUpperCase();
      }
      if ((hash3[i >> 1] & 15) >= 8 && address[i + 1]) {
        address[i + 1] = address[i + 1].toUpperCase();
      }
    }
    const result = `0x${address.join("")}`;
    checksumAddressCache.set(`${address_}.${chainId}`, result);
    return result;
  }
  function getAddress(address, chainId) {
    if (!isAddress(address, { strict: false }))
      throw new InvalidAddressError({ address });
    return checksumAddress(address, chainId);
  }
  var checksumAddressCache;
  var init_getAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getAddress.js"() {
      init_address();
      init_toBytes();
      init_keccak256();
      init_lru();
      init_isAddress();
      checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js
  function isAddress(address, options) {
    const { strict = true } = options ?? {};
    const cacheKey2 = `${address}.${strict}`;
    if (isAddressCache.has(cacheKey2))
      return isAddressCache.get(cacheKey2);
    const result = (() => {
      if (!addressRegex.test(address))
        return false;
      if (address.toLowerCase() === address)
        return true;
      if (strict)
        return checksumAddress(address) === address;
      return true;
    })();
    isAddressCache.set(cacheKey2, result);
    return result;
  }
  var addressRegex, isAddressCache;
  var init_isAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddress.js"() {
      init_lru();
      init_getAddress();
      addressRegex = /^0x[a-fA-F0-9]{40}$/;
      isAddressCache = /* @__PURE__ */ new LruMap(8192);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js
  function concat(values) {
    if (typeof values[0] === "string")
      return concatHex(values);
    return concatBytes2(values);
  }
  function concatBytes2(values) {
    let length = 0;
    for (const arr of values) {
      length += arr.length;
    }
    const result = new Uint8Array(length);
    let offset = 0;
    for (const arr of values) {
      result.set(arr, offset);
      offset += arr.length;
    }
    return result;
  }
  function concatHex(values) {
    return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
  }
  var init_concat = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/concat.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js
  function slice(value, start, end, { strict } = {}) {
    if (isHex(value, { strict: false }))
      return sliceHex(value, start, end, {
        strict
      });
    return sliceBytes(value, start, end, {
      strict
    });
  }
  function assertStartOffset(value, start) {
    if (typeof start === "number" && start > 0 && start > size(value) - 1)
      throw new SliceOffsetOutOfBoundsError({
        offset: start,
        position: "start",
        size: size(value)
      });
  }
  function assertEndOffset(value, start, end) {
    if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
      throw new SliceOffsetOutOfBoundsError({
        offset: end,
        position: "end",
        size: size(value)
      });
    }
  }
  function sliceBytes(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = value_.slice(start, end);
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  function sliceHex(value_, start, end, { strict } = {}) {
    assertStartOffset(value_, start);
    const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
    if (strict)
      assertEndOffset(value, start, end);
    return value;
  }
  var init_slice = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/slice.js"() {
      init_data();
      init_isHex();
      init_size();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
  function encodeAbiParameters(params, values) {
    if (params.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: params.length,
        givenLength: values.length
      });
    const preparedParams = prepareParams({
      params,
      values
    });
    const data = encodeParams(preparedParams);
    if (data.length === 0)
      return "0x";
    return data;
  }
  function prepareParams({ params, values }) {
    const preparedParams = [];
    for (let i = 0; i < params.length; i++) {
      preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
    }
    return preparedParams;
  }
  function prepareParam({ param, value }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return encodeArray(value, { length, param: { ...param, type } });
    }
    if (param.type === "tuple") {
      return encodeTuple(value, {
        param
      });
    }
    if (param.type === "address") {
      return encodeAddress(value);
    }
    if (param.type === "bool") {
      return encodeBool(value);
    }
    if (param.type.startsWith("uint") || param.type.startsWith("int")) {
      const signed = param.type.startsWith("int");
      return encodeNumber(value, { signed });
    }
    if (param.type.startsWith("bytes")) {
      return encodeBytes(value, { param });
    }
    if (param.type === "string") {
      return encodeString(value);
    }
    throw new InvalidAbiEncodingTypeError(param.type, {
      docsPath: "/docs/contract/encodeAbiParameters"
    });
  }
  function encodeParams(preparedParams) {
    let staticSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic)
        staticSize += 32;
      else
        staticSize += size(encoded);
    }
    const staticParams = [];
    const dynamicParams = [];
    let dynamicSize = 0;
    for (let i = 0; i < preparedParams.length; i++) {
      const { dynamic, encoded } = preparedParams[i];
      if (dynamic) {
        staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
        dynamicParams.push(encoded);
        dynamicSize += size(encoded);
      } else {
        staticParams.push(encoded);
      }
    }
    return concat([...staticParams, ...dynamicParams]);
  }
  function encodeAddress(value) {
    if (!isAddress(value))
      throw new InvalidAddressError({ address: value });
    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
  }
  function encodeArray(value, { length, param }) {
    const dynamic = length === null;
    if (!Array.isArray(value))
      throw new InvalidArrayError(value);
    if (!dynamic && value.length !== length)
      throw new AbiEncodingArrayLengthMismatchError({
        expectedLength: length,
        givenLength: value.length,
        type: `${param.type}[${length}]`
      });
    let dynamicChild = false;
    const preparedParams = [];
    for (let i = 0; i < value.length; i++) {
      const preparedParam = prepareParam({ param, value: value[i] });
      if (preparedParam.dynamic)
        dynamicChild = true;
      preparedParams.push(preparedParam);
    }
    if (dynamic || dynamicChild) {
      const data = encodeParams(preparedParams);
      if (dynamic) {
        const length2 = numberToHex(preparedParams.length, { size: 32 });
        return {
          dynamic: true,
          encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
        };
      }
      if (dynamicChild)
        return { dynamic: true, encoded: data };
    }
    return {
      dynamic: false,
      encoded: concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function encodeBytes(value, { param }) {
    const [, paramSize] = param.type.split("bytes");
    const bytesSize = size(value);
    if (!paramSize) {
      let value_ = value;
      if (bytesSize % 32 !== 0)
        value_ = padHex(value_, {
          dir: "right",
          size: Math.ceil((value.length - 2) / 2 / 32) * 32
        });
      return {
        dynamic: true,
        encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
      };
    }
    if (bytesSize !== Number.parseInt(paramSize))
      throw new AbiEncodingBytesSizeMismatchError({
        expectedSize: Number.parseInt(paramSize),
        value
      });
    return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
  }
  function encodeBool(value) {
    if (typeof value !== "boolean")
      throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
    return { dynamic: false, encoded: padHex(boolToHex(value)) };
  }
  function encodeNumber(value, { signed }) {
    return {
      dynamic: false,
      encoded: numberToHex(value, {
        size: 32,
        signed
      })
    };
  }
  function encodeString(value) {
    const hexValue = stringToHex(value);
    const partsLength = Math.ceil(size(hexValue) / 32);
    const parts = [];
    for (let i = 0; i < partsLength; i++) {
      parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
        dir: "right"
      }));
    }
    return {
      dynamic: true,
      encoded: concat([
        padHex(numberToHex(size(hexValue), { size: 32 })),
        ...parts
      ])
    };
  }
  function encodeTuple(value, { param }) {
    let dynamic = false;
    const preparedParams = [];
    for (let i = 0; i < param.components.length; i++) {
      const param_ = param.components[i];
      const index2 = Array.isArray(value) ? i : param_.name;
      const preparedParam = prepareParam({
        param: param_,
        value: value[index2]
      });
      preparedParams.push(preparedParam);
      if (preparedParam.dynamic)
        dynamic = true;
    }
    return {
      dynamic,
      encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
    };
  }
  function getArrayComponents(type) {
    const matches = type.match(/^(.*)\[(\d+)?\]$/);
    return matches ? (
      // Return `null` if the array is dynamic.
      [matches[2] ? Number(matches[2]) : null, matches[1]]
    ) : void 0;
  }
  var init_encodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
      init_abi();
      init_address();
      init_base();
      init_isAddress();
      init_concat();
      init_pad();
      init_size();
      init_slice();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
  var toFunctionSelector;
  var init_toFunctionSelector = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
      init_slice();
      init_toSignatureHash();
      toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js
  function getAbiItem(parameters) {
    const { abi: abi2, args = [], name } = parameters;
    const isSelector = isHex(name, { strict: false });
    const abiItems = abi2.filter((abiItem) => {
      if (isSelector) {
        if (abiItem.type === "function")
          return toFunctionSelector(abiItem) === name;
        if (abiItem.type === "event")
          return toEventSelector(abiItem) === name;
        return false;
      }
      return "name" in abiItem && abiItem.name === name;
    });
    if (abiItems.length === 0)
      return void 0;
    if (abiItems.length === 1)
      return abiItems[0];
    let matchedAbiItem = void 0;
    for (const abiItem of abiItems) {
      if (!("inputs" in abiItem))
        continue;
      if (!args || args.length === 0) {
        if (!abiItem.inputs || abiItem.inputs.length === 0)
          return abiItem;
        continue;
      }
      if (!abiItem.inputs)
        continue;
      if (abiItem.inputs.length === 0)
        continue;
      if (abiItem.inputs.length !== args.length)
        continue;
      const matched = args.every((arg, index2) => {
        const abiParameter = "inputs" in abiItem && abiItem.inputs[index2];
        if (!abiParameter)
          return false;
        return isArgOfType(arg, abiParameter);
      });
      if (matched) {
        if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
          const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
          if (ambiguousTypes)
            throw new AbiItemAmbiguityError({
              abiItem,
              type: ambiguousTypes[0]
            }, {
              abiItem: matchedAbiItem,
              type: ambiguousTypes[1]
            });
        }
        matchedAbiItem = abiItem;
      }
    }
    if (matchedAbiItem)
      return matchedAbiItem;
    return abiItems[0];
  }
  function isArgOfType(arg, abiParameter) {
    const argType = typeof arg;
    const abiParameterType = abiParameter.type;
    switch (abiParameterType) {
      case "address":
        return isAddress(arg, { strict: false });
      case "bool":
        return argType === "boolean";
      case "function":
        return argType === "string";
      case "string":
        return argType === "string";
      default: {
        if (abiParameterType === "tuple" && "components" in abiParameter)
          return Object.values(abiParameter.components).every((component, index2) => {
            return isArgOfType(Object.values(arg)[index2], component);
          });
        if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
          return argType === "number" || argType === "bigint";
        if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
          return argType === "string" || arg instanceof Uint8Array;
        if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
          return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
            ...abiParameter,
            // Pop off `[]` or `[M]` from end of type
            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
          }));
        }
        return false;
      }
    }
  }
  function getAmbiguousTypes(sourceParameters, targetParameters, args) {
    for (const parameterIndex in sourceParameters) {
      const sourceParameter = sourceParameters[parameterIndex];
      const targetParameter = targetParameters[parameterIndex];
      if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
        return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
      const types = [sourceParameter.type, targetParameter.type];
      const ambiguous = (() => {
        if (types.includes("address") && types.includes("bytes20"))
          return true;
        if (types.includes("address") && types.includes("string"))
          return isAddress(args[parameterIndex], { strict: false });
        if (types.includes("address") && types.includes("bytes"))
          return isAddress(args[parameterIndex], { strict: false });
        return false;
      })();
      if (ambiguous)
        return types;
    }
    return;
  }
  var init_getAbiItem = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
      init_abi();
      init_isHex();
      init_isAddress();
      init_toEventSelector();
      init_toFunctionSelector();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js
  function parseAccount(account) {
    if (typeof account === "string")
      return { address: account, type: "json-rpc" };
    return account;
  }
  var init_parseAccount = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/parseAccount.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
  function prepareEncodeFunctionData(parameters) {
    const { abi: abi2, args, functionName } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({
        abi: abi2,
        args,
        name: functionName
      });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath2 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath2 });
    return {
      abi: [abiItem],
      functionName: toFunctionSelector(formatAbiItem2(abiItem))
    };
  }
  var docsPath2;
  var init_prepareEncodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js"() {
      init_abi();
      init_toFunctionSelector();
      init_formatAbiItem2();
      init_getAbiItem();
      docsPath2 = "/docs/contract/encodeFunctionData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
  function encodeFunctionData(parameters) {
    const { args } = parameters;
    const { abi: abi2, functionName } = (() => {
      if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
        return parameters;
      return prepareEncodeFunctionData(parameters);
    })();
    const abiItem = abi2[0];
    const signature = functionName;
    const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
    return concatHex([signature, data ?? "0x"]);
  }
  var init_encodeFunctionData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionData.js"() {
      init_concat();
      init_encodeAbiParameters();
      init_prepareEncodeFunctionData();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js
  var panicReasons, solidityError, solidityPanic;
  var init_solidity = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/solidity.js"() {
      panicReasons = {
        1: "An `assert` condition failed.",
        17: "Arithmetic operation resulted in underflow or overflow.",
        18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
        33: "Attempted to convert to an invalid type.",
        34: "Attempted to access a storage byte array that is incorrectly encoded.",
        49: "Performed `.pop()` on an empty array",
        50: "Array index is out of bounds.",
        65: "Allocated too much memory or created an array which is too large.",
        81: "Attempted to call a zero-initialized variable of internal function type."
      };
      solidityError = {
        inputs: [
          {
            name: "message",
            type: "string"
          }
        ],
        name: "Error",
        type: "error"
      };
      solidityPanic = {
        inputs: [
          {
            name: "reason",
            type: "uint256"
          }
        ],
        name: "Panic",
        type: "error"
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js
  var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
  var init_cursor = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/cursor.js"() {
      init_base();
      NegativeOffsetError = class extends BaseError2 {
        constructor({ offset }) {
          super(`Offset \`${offset}\` cannot be negative.`, {
            name: "NegativeOffsetError"
          });
        }
      };
      PositionOutOfBoundsError = class extends BaseError2 {
        constructor({ length, position }) {
          super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
        }
      };
      RecursiveReadLimitExceededError = class extends BaseError2 {
        constructor({ count, limit }) {
          super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js
  function createCursor(bytes2, { recursiveReadLimit = 8192 } = {}) {
    const cursor = Object.create(staticCursor);
    cursor.bytes = bytes2;
    cursor.dataView = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
    cursor.positionReadCount = /* @__PURE__ */ new Map();
    cursor.recursiveReadLimit = recursiveReadLimit;
    return cursor;
  }
  var staticCursor;
  var init_cursor2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/cursor.js"() {
      init_cursor();
      staticCursor = {
        bytes: new Uint8Array(),
        dataView: new DataView(new ArrayBuffer(0)),
        position: 0,
        positionReadCount: /* @__PURE__ */ new Map(),
        recursiveReadCount: 0,
        recursiveReadLimit: Number.POSITIVE_INFINITY,
        assertReadLimit() {
          if (this.recursiveReadCount >= this.recursiveReadLimit)
            throw new RecursiveReadLimitExceededError({
              count: this.recursiveReadCount + 1,
              limit: this.recursiveReadLimit
            });
        },
        assertPosition(position) {
          if (position < 0 || position > this.bytes.length - 1)
            throw new PositionOutOfBoundsError({
              length: this.bytes.length,
              position
            });
        },
        decrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position - offset;
          this.assertPosition(position);
          this.position = position;
        },
        getReadCount(position) {
          return this.positionReadCount.get(position || this.position) || 0;
        },
        incrementPosition(offset) {
          if (offset < 0)
            throw new NegativeOffsetError({ offset });
          const position = this.position + offset;
          this.assertPosition(position);
          this.position = position;
        },
        inspectByte(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectBytes(length, position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + length - 1);
          return this.bytes.subarray(position, position + length);
        },
        inspectUint8(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position);
          return this.bytes[position];
        },
        inspectUint16(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 1);
          return this.dataView.getUint16(position);
        },
        inspectUint24(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 2);
          return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
        },
        inspectUint32(position_) {
          const position = position_ ?? this.position;
          this.assertPosition(position + 3);
          return this.dataView.getUint32(position);
        },
        pushByte(byte) {
          this.assertPosition(this.position);
          this.bytes[this.position] = byte;
          this.position++;
        },
        pushBytes(bytes2) {
          this.assertPosition(this.position + bytes2.length - 1);
          this.bytes.set(bytes2, this.position);
          this.position += bytes2.length;
        },
        pushUint8(value) {
          this.assertPosition(this.position);
          this.bytes[this.position] = value;
          this.position++;
        },
        pushUint16(value) {
          this.assertPosition(this.position + 1);
          this.dataView.setUint16(this.position, value);
          this.position += 2;
        },
        pushUint24(value) {
          this.assertPosition(this.position + 2);
          this.dataView.setUint16(this.position, value >> 8);
          this.dataView.setUint8(this.position + 2, value & ~4294967040);
          this.position += 3;
        },
        pushUint32(value) {
          this.assertPosition(this.position + 3);
          this.dataView.setUint32(this.position, value);
          this.position += 4;
        },
        readByte() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectByte();
          this.position++;
          return value;
        },
        readBytes(length, size3) {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectBytes(length);
          this.position += size3 ?? length;
          return value;
        },
        readUint8() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint8();
          this.position += 1;
          return value;
        },
        readUint16() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint16();
          this.position += 2;
          return value;
        },
        readUint24() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint24();
          this.position += 3;
          return value;
        },
        readUint32() {
          this.assertReadLimit();
          this._touch();
          const value = this.inspectUint32();
          this.position += 4;
          return value;
        },
        get remaining() {
          return this.bytes.length - this.position;
        },
        setPosition(position) {
          const oldPosition = this.position;
          this.assertPosition(position);
          this.position = position;
          return () => this.position = oldPosition;
        },
        _touch() {
          if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
            return;
          const count = this.getReadCount();
          this.positionReadCount.set(this.position, count + 1);
          if (count > 0)
            this.recursiveReadCount++;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js
  function fromBytes(bytes2, toOrOpts) {
    const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
    const to = opts.to;
    if (to === "number")
      return bytesToNumber(bytes2, opts);
    if (to === "bigint")
      return bytesToBigInt(bytes2, opts);
    if (to === "boolean")
      return bytesToBool(bytes2, opts);
    if (to === "string")
      return bytesToString(bytes2, opts);
    return bytesToHex(bytes2, opts);
  }
  function bytesToBigInt(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToBigInt(hex, opts);
  }
  function bytesToBool(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2);
    }
    if (bytes2.length > 1 || bytes2[0] > 1)
      throw new InvalidBytesBooleanError(bytes2);
    return Boolean(bytes2[0]);
  }
  function bytesToNumber(bytes2, opts = {}) {
    if (typeof opts.size !== "undefined")
      assertSize(bytes2, { size: opts.size });
    const hex = bytesToHex(bytes2, opts);
    return hexToNumber(hex, opts);
  }
  function bytesToString(bytes_, opts = {}) {
    let bytes2 = bytes_;
    if (typeof opts.size !== "undefined") {
      assertSize(bytes2, { size: opts.size });
      bytes2 = trim(bytes2, { dir: "right" });
    }
    return new TextDecoder().decode(bytes2);
  }
  var init_fromBytes = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
      init_encoding();
      init_trim();
      init_fromHex();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
  function decodeAbiParameters(params, data) {
    const bytes2 = typeof data === "string" ? hexToBytes(data) : data;
    const cursor = createCursor(bytes2);
    if (size(bytes2) === 0 && params.length > 0)
      throw new AbiDecodingZeroDataError();
    if (size(data) && size(data) < 32)
      throw new AbiDecodingDataSizeTooSmallError({
        data: typeof data === "string" ? data : bytesToHex(data),
        params,
        size: size(data)
      });
    let consumed = 0;
    const values = [];
    for (let i = 0; i < params.length; ++i) {
      const param = params[i];
      cursor.setPosition(consumed);
      const [data2, consumed_] = decodeParameter(cursor, param, {
        staticPosition: 0
      });
      consumed += consumed_;
      values.push(data2);
    }
    return values;
  }
  function decodeParameter(cursor, param, { staticPosition }) {
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents) {
      const [length, type] = arrayComponents;
      return decodeArray(cursor, { ...param, type }, { length, staticPosition });
    }
    if (param.type === "tuple")
      return decodeTuple(cursor, param, { staticPosition });
    if (param.type === "address")
      return decodeAddress(cursor);
    if (param.type === "bool")
      return decodeBool(cursor);
    if (param.type.startsWith("bytes"))
      return decodeBytes(cursor, param, { staticPosition });
    if (param.type.startsWith("uint") || param.type.startsWith("int"))
      return decodeNumber(cursor, param);
    if (param.type === "string")
      return decodeString(cursor, { staticPosition });
    throw new InvalidAbiDecodingTypeError(param.type, {
      docsPath: "/docs/contract/decodeAbiParameters"
    });
  }
  function decodeAddress(cursor) {
    const value = cursor.readBytes(32);
    return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
  }
  function decodeArray(cursor, param, { length, staticPosition }) {
    if (!length) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const startOfData = start + sizeOfLength;
      cursor.setPosition(start);
      const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
      const dynamicChild = hasDynamicChild(param);
      let consumed2 = 0;
      const value2 = [];
      for (let i = 0; i < length2; ++i) {
        cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
        const [data, consumed_] = decodeParameter(cursor, param, {
          staticPosition: startOfData
        });
        consumed2 += consumed_;
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      const value2 = [];
      for (let i = 0; i < length; ++i) {
        cursor.setPosition(start + i * 32);
        const [data] = decodeParameter(cursor, param, {
          staticPosition: start
        });
        value2.push(data);
      }
      cursor.setPosition(staticPosition + 32);
      return [value2, 32];
    }
    let consumed = 0;
    const value = [];
    for (let i = 0; i < length; ++i) {
      const [data, consumed_] = decodeParameter(cursor, param, {
        staticPosition: staticPosition + consumed
      });
      consumed += consumed_;
      value.push(data);
    }
    return [value, consumed];
  }
  function decodeBool(cursor) {
    return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
  }
  function decodeBytes(cursor, param, { staticPosition }) {
    const [_, size3] = param.type.split("bytes");
    if (!size3) {
      const offset = bytesToNumber(cursor.readBytes(32));
      cursor.setPosition(staticPosition + offset);
      const length = bytesToNumber(cursor.readBytes(32));
      if (length === 0) {
        cursor.setPosition(staticPosition + 32);
        return ["0x", 32];
      }
      const data = cursor.readBytes(length);
      cursor.setPosition(staticPosition + 32);
      return [bytesToHex(data), 32];
    }
    const value = bytesToHex(cursor.readBytes(Number.parseInt(size3), 32));
    return [value, 32];
  }
  function decodeNumber(cursor, param) {
    const signed = param.type.startsWith("int");
    const size3 = Number.parseInt(param.type.split("int")[1] || "256");
    const value = cursor.readBytes(32);
    return [
      size3 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
      32
    ];
  }
  function decodeTuple(cursor, param, { staticPosition }) {
    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
    const value = hasUnnamedChild ? [] : {};
    let consumed = 0;
    if (hasDynamicChild(param)) {
      const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
      const start = staticPosition + offset;
      for (let i = 0; i < param.components.length; ++i) {
        const component = param.components[i];
        cursor.setPosition(start + consumed);
        const [data, consumed_] = decodeParameter(cursor, component, {
          staticPosition: start
        });
        consumed += consumed_;
        value[hasUnnamedChild ? i : component?.name] = data;
      }
      cursor.setPosition(staticPosition + 32);
      return [value, 32];
    }
    for (let i = 0; i < param.components.length; ++i) {
      const component = param.components[i];
      const [data, consumed_] = decodeParameter(cursor, component, {
        staticPosition
      });
      value[hasUnnamedChild ? i : component?.name] = data;
      consumed += consumed_;
    }
    return [value, consumed];
  }
  function decodeString(cursor, { staticPosition }) {
    const offset = bytesToNumber(cursor.readBytes(32));
    const start = staticPosition + offset;
    cursor.setPosition(start);
    const length = bytesToNumber(cursor.readBytes(32));
    if (length === 0) {
      cursor.setPosition(staticPosition + 32);
      return ["", 32];
    }
    const data = cursor.readBytes(length, 32);
    const value = bytesToString(trim(data));
    cursor.setPosition(staticPosition + 32);
    return [value, 32];
  }
  function hasDynamicChild(param) {
    const { type } = param;
    if (type === "string")
      return true;
    if (type === "bytes")
      return true;
    if (type.endsWith("[]"))
      return true;
    if (type === "tuple")
      return param.components?.some(hasDynamicChild);
    const arrayComponents = getArrayComponents(param.type);
    if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
      return true;
    return false;
  }
  var sizeOfLength, sizeOfOffset;
  var init_decodeAbiParameters = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
      init_abi();
      init_getAddress();
      init_cursor2();
      init_size();
      init_slice();
      init_trim();
      init_fromBytes();
      init_toBytes();
      init_toHex();
      init_encodeAbiParameters();
      sizeOfLength = 32;
      sizeOfOffset = 32;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
  function decodeErrorResult(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    if (signature === "0x")
      throw new AbiDecodingZeroDataError();
    const abi_ = [...abi2 || [], solidityError, solidityPanic];
    const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!abiItem)
      throw new AbiErrorSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeErrorResult"
      });
    return {
      abiItem,
      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
      errorName: abiItem.name
    };
  }
  var init_decodeErrorResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeErrorResult.js"() {
      init_solidity();
      init_abi();
      init_slice();
      init_toFunctionSelector();
      init_decodeAbiParameters();
      init_formatAbiItem2();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js
  var stringify;
  var init_stringify = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stringify.js"() {
      stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
        const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
        return typeof replacer === "function" ? replacer(key, value2) : value2;
      }, space);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
  function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
    if (!("name" in abiItem))
      return;
    if (!("inputs" in abiItem))
      return;
    if (!abiItem.inputs)
      return;
    return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
  }
  var init_formatAbiItemWithArgs = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js"() {
      init_stringify();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js
  var etherUnits, gweiUnits, weiUnits;
  var init_unit = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/unit.js"() {
      etherUnits = {
        gwei: 9,
        wei: 18
      };
      gweiUnits = {
        ether: -9,
        wei: 9
      };
      weiUnits = {
        ether: -18,
        gwei: -9
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js
  function formatUnits(value, decimals) {
    let display = value.toString();
    const negative = display.startsWith("-");
    if (negative)
      display = display.slice(1);
    display = display.padStart(decimals, "0");
    let [integer, fraction] = [
      display.slice(0, display.length - decimals),
      display.slice(display.length - decimals)
    ];
    fraction = fraction.replace(/(0+)$/, "");
    return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
  }
  var init_formatUnits = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatUnits.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js
  function formatEther(wei, unit = "wei") {
    return formatUnits(wei, etherUnits[unit]);
  }
  var init_formatEther = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatEther.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js
  function formatGwei(wei, unit = "wei") {
    return formatUnits(wei, gweiUnits[unit]);
  }
  var init_formatGwei = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/formatGwei.js"() {
      init_unit();
      init_formatUnits();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js
  function prettyStateMapping(stateMapping) {
    return stateMapping.reduce((pretty, { slot, value }) => {
      return `${pretty}        ${slot}: ${value}
`;
    }, "");
  }
  function prettyStateOverride(stateOverride) {
    return stateOverride.reduce((pretty, { address, ...state }) => {
      let val = `${pretty}    ${address}:
`;
      if (state.nonce)
        val += `      nonce: ${state.nonce}
`;
      if (state.balance)
        val += `      balance: ${state.balance}
`;
      if (state.code)
        val += `      code: ${state.code}
`;
      if (state.state) {
        val += "      state:\n";
        val += prettyStateMapping(state.state);
      }
      if (state.stateDiff) {
        val += "      stateDiff:\n";
        val += prettyStateMapping(state.stateDiff);
      }
      return val;
    }, "  State Override:\n").slice(0, -1);
  }
  var AccountStateConflictError, StateAssignmentConflictError;
  var init_stateOverride = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/stateOverride.js"() {
      init_base();
      AccountStateConflictError = class extends BaseError2 {
        constructor({ address }) {
          super(`State for account "${address}" is set multiple times.`, {
            name: "AccountStateConflictError"
          });
        }
      };
      StateAssignmentConflictError = class extends BaseError2 {
        constructor() {
          super("state and stateDiff are set on the same account.", {
            name: "StateAssignmentConflictError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js
  function prettyPrint(args) {
    const entries = Object.entries(args).map(([key, value]) => {
      if (value === void 0 || value === false)
        return null;
      return [key, value];
    }).filter(Boolean);
    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
    return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
  }
  var FeeConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidSerializedTransactionTypeError, InvalidSerializedTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, WaitForTransactionReceiptTimeoutError;
  var init_transaction = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transaction.js"() {
      init_formatEther();
      init_formatGwei();
      init_base();
      FeeConflictError = class extends BaseError2 {
        constructor() {
          super([
            "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
            "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
          ].join("\n"), { name: "FeeConflictError" });
        }
      };
      InvalidLegacyVError = class extends BaseError2 {
        constructor({ v }) {
          super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
            name: "InvalidLegacyVError"
          });
        }
      };
      InvalidSerializableTransactionError = class extends BaseError2 {
        constructor({ transaction }) {
          super("Cannot infer a transaction type from provided transaction.", {
            metaMessages: [
              "Provided Transaction:",
              "{",
              prettyPrint(transaction),
              "}",
              "",
              "To infer the type, either provide:",
              "- a `type` to the Transaction, or",
              "- an EIP-1559 Transaction with `maxFeePerGas`, or",
              "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
              "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
              "- an EIP-7702 Transaction with `authorizationList`, or",
              "- a Legacy Transaction with `gasPrice`"
            ],
            name: "InvalidSerializableTransactionError"
          });
        }
      };
      InvalidSerializedTransactionTypeError = class extends BaseError2 {
        constructor({ serializedType }) {
          super(`Serialized transaction type "${serializedType}" is invalid.`, {
            name: "InvalidSerializedTransactionType"
          });
          Object.defineProperty(this, "serializedType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedType = serializedType;
        }
      };
      InvalidSerializedTransactionError = class extends BaseError2 {
        constructor({ attributes, serializedTransaction, type }) {
          const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
          super(`Invalid serialized transaction of type "${type}" was provided.`, {
            metaMessages: [
              `Serialized Transaction: "${serializedTransaction}"`,
              missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
            ].filter(Boolean),
            name: "InvalidSerializedTransactionError"
          });
          Object.defineProperty(this, "serializedTransaction", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.serializedTransaction = serializedTransaction;
          this.type = type;
        }
      };
      InvalidStorageKeySizeError = class extends BaseError2 {
        constructor({ storageKey }) {
          super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
        }
      };
      TransactionExecutionError = class extends BaseError2 {
        constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
          const prettyArgs = prettyPrint({
            chain: chain && `${chain?.name} (id: ${chain?.id})`,
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Request Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "TransactionExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      TransactionNotFoundError = class extends BaseError2 {
        constructor({ blockHash, blockNumber, blockTag, hash: hash3, index: index2 }) {
          let identifier = "Transaction";
          if (blockTag && index2 !== void 0)
            identifier = `Transaction at block time "${blockTag}" at index "${index2}"`;
          if (blockHash && index2 !== void 0)
            identifier = `Transaction at block hash "${blockHash}" at index "${index2}"`;
          if (blockNumber && index2 !== void 0)
            identifier = `Transaction at block number "${blockNumber}" at index "${index2}"`;
          if (hash3)
            identifier = `Transaction with hash "${hash3}"`;
          super(`${identifier} could not be found.`, {
            name: "TransactionNotFoundError"
          });
        }
      };
      TransactionReceiptNotFoundError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Transaction receipt with hash "${hash3}" could not be found. The Transaction may not be processed on a block yet.`, {
            name: "TransactionReceiptNotFoundError"
          });
        }
      };
      WaitForTransactionReceiptTimeoutError = class extends BaseError2 {
        constructor({ hash: hash3 }) {
          super(`Timed out while waiting for transaction with hash "${hash3}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js
  var getContractAddress, getUrl;
  var init_utils3 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/utils.js"() {
      getContractAddress = (address) => address;
      getUrl = (url) => url;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js
  var CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError;
  var init_contract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/contract.js"() {
      init_parseAccount();
      init_solidity();
      init_decodeErrorResult();
      init_formatAbiItem2();
      init_formatAbiItemWithArgs();
      init_getAbiItem();
      init_formatEther();
      init_formatGwei();
      init_abi();
      init_base();
      init_stateOverride();
      init_transaction();
      init_utils3();
      CallExecutionError = class extends BaseError2 {
        constructor(cause, { account: account_, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
          const account = account_ ? parseAccount(account_) : void 0;
          let prettyArgs = prettyPrint({
            from: account?.address,
            to,
            value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
            data,
            gas,
            gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
            maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
            maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
            nonce
          });
          if (stateOverride) {
            prettyArgs += `
${prettyStateOverride(stateOverride)}`;
          }
          super(cause.shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              "Raw Call Arguments:",
              prettyArgs
            ].filter(Boolean),
            name: "CallExecutionError"
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.cause = cause;
        }
      };
      ContractFunctionExecutionError = class extends BaseError2 {
        constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
          const abiItem = getAbiItem({ abi: abi2, args, name: functionName });
          const formattedArgs = abiItem ? formatAbiItemWithArgs({
            abiItem,
            args,
            includeFunctionName: false,
            includeName: false
          }) : void 0;
          const functionWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
          const prettyArgs = prettyPrint({
            address: contractAddress && getContractAddress(contractAddress),
            function: functionWithParams,
            args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
            sender
          });
          super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
            cause,
            docsPath: docsPath9,
            metaMessages: [
              ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
              prettyArgs && "Contract Call:",
              prettyArgs
            ].filter(Boolean),
            name: "ContractFunctionExecutionError"
          });
          Object.defineProperty(this, "abi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "args", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "cause", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "contractAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "formattedArgs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "functionName", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "sender", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.abi = abi2;
          this.args = args;
          this.cause = cause;
          this.contractAddress = contractAddress;
          this.functionName = functionName;
          this.sender = sender;
        }
      };
      ContractFunctionRevertedError = class extends BaseError2 {
        constructor({ abi: abi2, data, functionName, message }) {
          let cause;
          let decodedData = void 0;
          let metaMessages;
          let reason;
          if (data && data !== "0x") {
            try {
              decodedData = decodeErrorResult({ abi: abi2, data });
              const { abiItem, errorName, args: errorArgs } = decodedData;
              if (errorName === "Error") {
                reason = errorArgs[0];
              } else if (errorName === "Panic") {
                const [firstArg] = errorArgs;
                reason = panicReasons[firstArg];
              } else {
                const errorWithParams = abiItem ? formatAbiItem2(abiItem, { includeName: true }) : void 0;
                const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
                  abiItem,
                  args: errorArgs,
                  includeFunctionName: false,
                  includeName: false
                }) : void 0;
                metaMessages = [
                  errorWithParams ? `Error: ${errorWithParams}` : "",
                  formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
                ];
              }
            } catch (err) {
              cause = err;
            }
          } else if (message)
            reason = message;
          let signature;
          if (cause instanceof AbiErrorSignatureNotFoundError) {
            signature = cause.signature;
            metaMessages = [
              `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
              "Make sure you are using the correct ABI and that the error exists on it.",
              `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
            ];
          }
          super(reason && reason !== "execution reverted" || signature ? [
            `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
            reason || signature
          ].join("\n") : `The contract function "${functionName}" reverted.`, {
            cause,
            metaMessages,
            name: "ContractFunctionRevertedError"
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "reason", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "signature", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = decodedData;
          this.reason = reason;
          this.signature = signature;
        }
      };
      ContractFunctionZeroDataError = class extends BaseError2 {
        constructor({ functionName }) {
          super(`The contract function "${functionName}" returned no data ("0x").`, {
            metaMessages: [
              "This could be due to any of the following:",
              `  - The contract does not have the function "${functionName}",`,
              "  - The parameters passed to the contract function may be invalid, or",
              "  - The address is not a contract."
            ],
            name: "ContractFunctionZeroDataError"
          });
        }
      };
      CounterfactualDeploymentFailedError = class extends BaseError2 {
        constructor({ factory }) {
          super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
            metaMessages: [
              "Please ensure:",
              "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
              "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
            ],
            name: "CounterfactualDeploymentFailedError"
          });
        }
      };
      RawContractError = class extends BaseError2 {
        constructor({ data, message }) {
          super(message || "", { name: "RawContractError" });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 3
          });
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = data;
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js
  var HttpRequestError, WebSocketRequestError, RpcRequestError, SocketClosedError, TimeoutError;
  var init_request = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/request.js"() {
      init_stringify();
      init_base();
      init_utils3();
      HttpRequestError = class extends BaseError2 {
        constructor({ body, cause, details, headers, status, url }) {
          super("HTTP request failed.", {
            cause,
            details,
            metaMessages: [
              status && `Status: ${status}`,
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "HttpRequestError"
          });
          Object.defineProperty(this, "body", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "headers", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "status", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "url", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.body = body;
          this.headers = headers;
          this.status = status;
          this.url = url;
        }
      };
      WebSocketRequestError = class extends BaseError2 {
        constructor({ body, cause, details, url }) {
          super("WebSocket request failed.", {
            cause,
            details,
            metaMessages: [
              `URL: ${getUrl(url)}`,
              body && `Request body: ${stringify(body)}`
            ].filter(Boolean),
            name: "WebSocketRequestError"
          });
        }
      };
      RpcRequestError = class extends BaseError2 {
        constructor({ body, error, url }) {
          super("RPC Request failed.", {
            cause: error,
            details: error.message,
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "RpcRequestError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.code = error.code;
        }
      };
      SocketClosedError = class extends BaseError2 {
        constructor({ url } = {}) {
          super("The socket has been closed.", {
            metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean),
            name: "SocketClosedError"
          });
        }
      };
      TimeoutError = class extends BaseError2 {
        constructor({ body, url }) {
          super("The request took too long to respond.", {
            details: "The request timed out.",
            metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
            name: "TimeoutError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js
  var unknownErrorCode, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnknownRpcError;
  var init_rpc = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/rpc.js"() {
      init_base();
      init_request();
      unknownErrorCode = -1;
      RpcError = class extends BaseError2 {
        constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
          super(shortMessage, {
            cause,
            docsPath: docsPath9,
            metaMessages: metaMessages || cause?.metaMessages,
            name: name || "RpcError"
          });
          Object.defineProperty(this, "code", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.name = name || cause.name;
          this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
        }
      };
      ProviderRpcError = class extends RpcError {
        constructor(cause, options) {
          super(cause, options);
          Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.data = options.data;
        }
      };
      ParseRpcError = class _ParseRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ParseRpcError.code,
            name: "ParseRpcError",
            shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
          });
        }
      };
      Object.defineProperty(ParseRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32700
      });
      InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidRequestRpcError.code,
            name: "InvalidRequestRpcError",
            shortMessage: "JSON is not a valid request object."
          });
        }
      };
      Object.defineProperty(InvalidRequestRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32600
      });
      MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotFoundRpcError.code,
            name: "MethodNotFoundRpcError",
            shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
          });
        }
      };
      Object.defineProperty(MethodNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32601
      });
      InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidParamsRpcError.code,
            name: "InvalidParamsRpcError",
            shortMessage: [
              "Invalid parameters were provided to the RPC method.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidParamsRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32602
      });
      InternalRpcError = class _InternalRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InternalRpcError.code,
            name: "InternalRpcError",
            shortMessage: "An internal error was received."
          });
        }
      };
      Object.defineProperty(InternalRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32603
      });
      InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _InvalidInputRpcError.code,
            name: "InvalidInputRpcError",
            shortMessage: [
              "Missing or invalid parameters.",
              "Double check you have provided the correct parameters."
            ].join("\n")
          });
        }
      };
      Object.defineProperty(InvalidInputRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32e3
      });
      ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceNotFoundRpcError.code,
            name: "ResourceNotFoundRpcError",
            shortMessage: "Requested resource not found."
          });
          Object.defineProperty(this, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: "ResourceNotFoundRpcError"
          });
        }
      };
      Object.defineProperty(ResourceNotFoundRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32001
      });
      ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _ResourceUnavailableRpcError.code,
            name: "ResourceUnavailableRpcError",
            shortMessage: "Requested resource not available."
          });
        }
      };
      Object.defineProperty(ResourceUnavailableRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32002
      });
      TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _TransactionRejectedRpcError.code,
            name: "TransactionRejectedRpcError",
            shortMessage: "Transaction creation failed."
          });
        }
      };
      Object.defineProperty(TransactionRejectedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32003
      });
      MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _MethodNotSupportedRpcError.code,
            name: "MethodNotSupportedRpcError",
            shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
          });
        }
      };
      Object.defineProperty(MethodNotSupportedRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32004
      });
      LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _LimitExceededRpcError.code,
            name: "LimitExceededRpcError",
            shortMessage: "Request exceeds defined limit."
          });
        }
      };
      Object.defineProperty(LimitExceededRpcError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32005
      });
      JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
        constructor(cause) {
          super(cause, {
            code: _JsonRpcVersionUnsupportedError.code,
            name: "JsonRpcVersionUnsupportedError",
            shortMessage: "Version of JSON-RPC protocol is not supported."
          });
        }
      };
      Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: -32006
      });
      UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UserRejectedRequestError.code,
            name: "UserRejectedRequestError",
            shortMessage: "User rejected the request."
          });
        }
      };
      Object.defineProperty(UserRejectedRequestError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4001
      });
      UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _UnauthorizedProviderError.code,
            name: "UnauthorizedProviderError",
            shortMessage: "The requested method and/or account has not been authorized by the user."
          });
        }
      };
      Object.defineProperty(UnauthorizedProviderError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4100
      });
      UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
        constructor(cause, { method } = {}) {
          super(cause, {
            code: _UnsupportedProviderMethodError.code,
            name: "UnsupportedProviderMethodError",
            shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
          });
        }
      };
      Object.defineProperty(UnsupportedProviderMethodError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4200
      });
      ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ProviderDisconnectedError.code,
            name: "ProviderDisconnectedError",
            shortMessage: "The Provider is disconnected from all chains."
          });
        }
      };
      Object.defineProperty(ProviderDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4900
      });
      ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _ChainDisconnectedError.code,
            name: "ChainDisconnectedError",
            shortMessage: "The Provider is not connected to the requested chain."
          });
        }
      };
      Object.defineProperty(ChainDisconnectedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4901
      });
      SwitchChainError = class _SwitchChainError extends ProviderRpcError {
        constructor(cause) {
          super(cause, {
            code: _SwitchChainError.code,
            name: "SwitchChainError",
            shortMessage: "An error occurred when attempting to switch chain."
          });
        }
      };
      Object.defineProperty(SwitchChainError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 4902
      });
      UnknownRpcError = class extends RpcError {
        constructor(cause) {
          super(cause, {
            name: "UnknownRpcError",
            shortMessage: "An unknown RPC error occurred."
          });
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
  function setBigUint64(view, byteOffset, value, isLE2) {
    if (typeof view.setBigUint64 === "function")
      return view.setBigUint64(byteOffset, value, isLE2);
    const _32n2 = BigInt(32);
    const _u32_max = BigInt(4294967295);
    const wh = Number(value >> _32n2 & _u32_max);
    const wl = Number(value & _u32_max);
    const h = isLE2 ? 4 : 0;
    const l = isLE2 ? 0 : 4;
    view.setUint32(byteOffset + h, wh, isLE2);
    view.setUint32(byteOffset + l, wl, isLE2);
  }
  var Chi, Maj, HashMD;
  var init_md = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js"() {
      init_assert();
      init_utils2();
      Chi = (a, b, c) => a & b ^ ~a & c;
      Maj = (a, b, c) => a & b ^ a & c ^ b & c;
      HashMD = class extends Hash {
        constructor(blockLen, outputLen, padOffset, isLE2) {
          super();
          this.blockLen = blockLen;
          this.outputLen = outputLen;
          this.padOffset = padOffset;
          this.isLE = isLE2;
          this.finished = false;
          this.length = 0;
          this.pos = 0;
          this.destroyed = false;
          this.buffer = new Uint8Array(blockLen);
          this.view = createView(this.buffer);
        }
        update(data) {
          exists(this);
          const { view, buffer: buffer2, blockLen } = this;
          data = toBytes2(data);
          const len = data.length;
          for (let pos = 0; pos < len; ) {
            const take = Math.min(blockLen - this.pos, len - pos);
            if (take === blockLen) {
              const dataView = createView(data);
              for (; blockLen <= len - pos; pos += blockLen)
                this.process(dataView, pos);
              continue;
            }
            buffer2.set(data.subarray(pos, pos + take), this.pos);
            this.pos += take;
            pos += take;
            if (this.pos === blockLen) {
              this.process(view, 0);
              this.pos = 0;
            }
          }
          this.length += data.length;
          this.roundClean();
          return this;
        }
        digestInto(out) {
          exists(this);
          output(out, this);
          this.finished = true;
          const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
          let { pos } = this;
          buffer2[pos++] = 128;
          this.buffer.subarray(pos).fill(0);
          if (this.padOffset > blockLen - pos) {
            this.process(view, 0);
            pos = 0;
          }
          for (let i = pos; i < blockLen; i++)
            buffer2[i] = 0;
          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
          this.process(view, 0);
          const oview = createView(out);
          const len = this.outputLen;
          if (len % 4)
            throw new Error("_sha2: outputLen should be aligned to 32bit");
          const outLen = len / 4;
          const state = this.get();
          if (outLen > state.length)
            throw new Error("_sha2: outputLen bigger than state");
          for (let i = 0; i < outLen; i++)
            oview.setUint32(4 * i, state[i], isLE2);
        }
        digest() {
          const { buffer: buffer2, outputLen } = this;
          this.digestInto(buffer2);
          const res = buffer2.slice(0, outputLen);
          this.destroy();
          return res;
        }
        _cloneInto(to) {
          to || (to = new this.constructor());
          to.set(...this.get());
          const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
          to.length = length;
          to.pos = pos;
          to.finished = finished;
          to.destroyed = destroyed;
          if (length % blockLen)
            to.buffer.set(buffer2);
          return to;
        }
      };
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
  var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
  var init_sha256 = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js"() {
      init_md();
      init_utils2();
      SHA256_K = /* @__PURE__ */ new Uint32Array([
        1116352408,
        1899447441,
        3049323471,
        3921009573,
        961987163,
        1508970993,
        2453635748,
        2870763221,
        3624381080,
        310598401,
        607225278,
        1426881987,
        1925078388,
        2162078206,
        2614888103,
        3248222580,
        3835390401,
        4022224774,
        264347078,
        604807628,
        770255983,
        1249150122,
        1555081692,
        1996064986,
        2554220882,
        2821834349,
        2952996808,
        3210313671,
        3336571891,
        3584528711,
        113926993,
        338241895,
        666307205,
        773529912,
        1294757372,
        1396182291,
        1695183700,
        1986661051,
        2177026350,
        2456956037,
        2730485921,
        2820302411,
        3259730800,
        3345764771,
        3516065817,
        3600352804,
        4094571909,
        275423344,
        430227734,
        506948616,
        659060556,
        883997877,
        958139571,
        1322822218,
        1537002063,
        1747873779,
        1955562222,
        2024104815,
        2227730452,
        2361852424,
        2428436474,
        2756734187,
        3204031479,
        3329325298
      ]);
      SHA256_IV = /* @__PURE__ */ new Uint32Array([
        1779033703,
        3144134277,
        1013904242,
        2773480762,
        1359893119,
        2600822924,
        528734635,
        1541459225
      ]);
      SHA256_W = /* @__PURE__ */ new Uint32Array(64);
      SHA256 = class extends HashMD {
        constructor() {
          super(64, 32, 8, false);
          this.A = SHA256_IV[0] | 0;
          this.B = SHA256_IV[1] | 0;
          this.C = SHA256_IV[2] | 0;
          this.D = SHA256_IV[3] | 0;
          this.E = SHA256_IV[4] | 0;
          this.F = SHA256_IV[5] | 0;
          this.G = SHA256_IV[6] | 0;
          this.H = SHA256_IV[7] | 0;
        }
        get() {
          const { A, B, C, D, E, F, G, H } = this;
          return [A, B, C, D, E, F, G, H];
        }
        // prettier-ignore
        set(A, B, C, D, E, F, G, H) {
          this.A = A | 0;
          this.B = B | 0;
          this.C = C | 0;
          this.D = D | 0;
          this.E = E | 0;
          this.F = F | 0;
          this.G = G | 0;
          this.H = H | 0;
        }
        process(view, offset) {
          for (let i = 0; i < 16; i++, offset += 4)
            SHA256_W[i] = view.getUint32(offset, false);
          for (let i = 16; i < 64; i++) {
            const W15 = SHA256_W[i - 15];
            const W2 = SHA256_W[i - 2];
            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
            SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
          }
          let { A, B, C, D, E, F, G, H } = this;
          for (let i = 0; i < 64; i++) {
            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
            const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
            const T2 = sigma0 + Maj(A, B, C) | 0;
            H = G;
            G = F;
            F = E;
            E = D + T1 | 0;
            D = C;
            C = B;
            B = A;
            A = T1 + T2 | 0;
          }
          A = A + this.A | 0;
          B = B + this.B | 0;
          C = C + this.C | 0;
          D = D + this.D | 0;
          E = E + this.E | 0;
          F = F + this.F | 0;
          G = G + this.G | 0;
          H = H + this.H | 0;
          this.set(A, B, C, D, E, F, G, H);
        }
        roundClean() {
          SHA256_W.fill(0);
        }
        destroy() {
          this.set(0, 0, 0, 0, 0, 0, 0, 0);
          this.buffer.fill(0);
        }
      };
      sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
    }
  });

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
  var HMAC, hmac;
  var init_hmac = __esm({
    "node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js"() {
      init_assert();
      init_utils2();
      HMAC = class extends Hash {
        constructor(hash3, _key) {
          super();
          this.finished = false;
          this.destroyed = false;
          hash(hash3);
          const key = toBytes2(_key);
          this.iHash = hash3.create();
          if (typeof this.iHash.update !== "function")
            throw new Error("Expected instance of class which extends utils.Hash");
          this.blockLen = this.iHash.blockLen;
          this.outputLen = this.iHash.outputLen;
          const blockLen = this.blockLen;
          const pad2 = new Uint8Array(blockLen);
          pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54;
          this.iHash.update(pad2);
          this.oHash = hash3.create();
          for (let i = 0; i < pad2.length; i++)
            pad2[i] ^= 54 ^ 92;
          this.oHash.update(pad2);
          pad2.fill(0);
        }
        update(buf) {
          exists(this);
          this.iHash.update(buf);
          return this;
        }
        digestInto(out) {
          exists(this);
          bytes(out, this.outputLen);
          this.finished = true;
          this.iHash.digestInto(out);
          this.oHash.update(out);
          this.oHash.digestInto(out);
          this.destroy();
        }
        digest() {
          const out = new Uint8Array(this.oHash.outputLen);
          this.digestInto(out);
          return out;
        }
        _cloneInto(to) {
          to || (to = Object.create(Object.getPrototypeOf(this), {}));
          const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
          to = to;
          to.finished = finished;
          to.destroyed = destroyed;
          to.blockLen = blockLen;
          to.outputLen = outputLen;
          to.oHash = oHash._cloneInto(to.oHash);
          to.iHash = iHash._cloneInto(to.iHash);
          return to;
        }
        destroy() {
          this.destroyed = true;
          this.oHash.destroy();
          this.iHash.destroy();
        }
      };
      hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
      hmac.create = (hash3, key) => new HMAC(hash3, key);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
  var utils_exports = {};
  __export(utils_exports, {
    aInRange: () => aInRange,
    abool: () => abool,
    abytes: () => abytes,
    bitGet: () => bitGet,
    bitLen: () => bitLen,
    bitMask: () => bitMask,
    bitSet: () => bitSet,
    bytesToHex: () => bytesToHex2,
    bytesToNumberBE: () => bytesToNumberBE,
    bytesToNumberLE: () => bytesToNumberLE,
    concatBytes: () => concatBytes3,
    createHmacDrbg: () => createHmacDrbg,
    ensureBytes: () => ensureBytes,
    equalBytes: () => equalBytes,
    hexToBytes: () => hexToBytes2,
    hexToNumber: () => hexToNumber2,
    inRange: () => inRange,
    isBytes: () => isBytes2,
    memoized: () => memoized,
    notImplemented: () => notImplemented,
    numberToBytesBE: () => numberToBytesBE,
    numberToBytesLE: () => numberToBytesLE,
    numberToHexUnpadded: () => numberToHexUnpadded,
    numberToVarBytesBE: () => numberToVarBytesBE,
    utf8ToBytes: () => utf8ToBytes2,
    validateObject: () => validateObject
  });
  function isBytes2(a) {
    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
  }
  function abytes(item) {
    if (!isBytes2(item))
      throw new Error("Uint8Array expected");
  }
  function abool(title, value) {
    if (typeof value !== "boolean")
      throw new Error(`${title} must be valid boolean, got "${value}".`);
  }
  function bytesToHex2(bytes2) {
    abytes(bytes2);
    let hex = "";
    for (let i = 0; i < bytes2.length; i++) {
      hex += hexes2[bytes2[i]];
    }
    return hex;
  }
  function numberToHexUnpadded(num2) {
    const hex = num2.toString(16);
    return hex.length & 1 ? `0${hex}` : hex;
  }
  function hexToNumber2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    return BigInt(hex === "" ? "0" : `0x${hex}`);
  }
  function asciiToBase16(char) {
    if (char >= asciis._0 && char <= asciis._9)
      return char - asciis._0;
    if (char >= asciis._A && char <= asciis._F)
      return char - (asciis._A - 10);
    if (char >= asciis._a && char <= asciis._f)
      return char - (asciis._a - 10);
    return;
  }
  function hexToBytes2(hex) {
    if (typeof hex !== "string")
      throw new Error("hex string expected, got " + typeof hex);
    const hl = hex.length;
    const al = hl / 2;
    if (hl % 2)
      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
    const array = new Uint8Array(al);
    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
      const n1 = asciiToBase16(hex.charCodeAt(hi));
      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
      if (n1 === void 0 || n2 === void 0) {
        const char = hex[hi] + hex[hi + 1];
        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
      }
      array[ai] = n1 * 16 + n2;
    }
    return array;
  }
  function bytesToNumberBE(bytes2) {
    return hexToNumber2(bytesToHex2(bytes2));
  }
  function bytesToNumberLE(bytes2) {
    abytes(bytes2);
    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
  }
  function numberToBytesBE(n, len) {
    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
  }
  function numberToBytesLE(n, len) {
    return numberToBytesBE(n, len).reverse();
  }
  function numberToVarBytesBE(n) {
    return hexToBytes2(numberToHexUnpadded(n));
  }
  function ensureBytes(title, hex, expectedLength) {
    let res;
    if (typeof hex === "string") {
      try {
        res = hexToBytes2(hex);
      } catch (e) {
        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
      }
    } else if (isBytes2(hex)) {
      res = Uint8Array.from(hex);
    } else {
      throw new Error(`${title} must be hex string or Uint8Array`);
    }
    const len = res.length;
    if (typeof expectedLength === "number" && len !== expectedLength)
      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
    return res;
  }
  function concatBytes3(...arrays) {
    let sum = 0;
    for (let i = 0; i < arrays.length; i++) {
      const a = arrays[i];
      abytes(a);
      sum += a.length;
    }
    const res = new Uint8Array(sum);
    for (let i = 0, pad2 = 0; i < arrays.length; i++) {
      const a = arrays[i];
      res.set(a, pad2);
      pad2 += a.length;
    }
    return res;
  }
  function equalBytes(a, b) {
    if (a.length !== b.length)
      return false;
    let diff = 0;
    for (let i = 0; i < a.length; i++)
      diff |= a[i] ^ b[i];
    return diff === 0;
  }
  function utf8ToBytes2(str) {
    if (typeof str !== "string")
      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
    return new Uint8Array(new TextEncoder().encode(str));
  }
  function inRange(n, min, max) {
    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
  }
  function aInRange(title, n, min, max) {
    if (!inRange(n, min, max))
      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
  }
  function bitLen(n) {
    let len;
    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
      ;
    return len;
  }
  function bitGet(n, pos) {
    return n >> BigInt(pos) & _1n2;
  }
  function bitSet(n, pos, value) {
    return n | (value ? _1n2 : _0n2) << BigInt(pos);
  }
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
    if (typeof hashLen !== "number" || hashLen < 2)
      throw new Error("hashLen must be a number");
    if (typeof qByteLen !== "number" || qByteLen < 2)
      throw new Error("qByteLen must be a number");
    if (typeof hmacFn !== "function")
      throw new Error("hmacFn must be a function");
    let v = u8n(hashLen);
    let k = u8n(hashLen);
    let i = 0;
    const reset2 = () => {
      v.fill(1);
      k.fill(0);
      i = 0;
    };
    const h = (...b) => hmacFn(k, v, ...b);
    const reseed = (seed = u8n()) => {
      k = h(u8fr([0]), seed);
      v = h();
      if (seed.length === 0)
        return;
      k = h(u8fr([1]), seed);
      v = h();
    };
    const gen2 = () => {
      if (i++ >= 1e3)
        throw new Error("drbg: tried 1000 values");
      let len = 0;
      const out = [];
      while (len < qByteLen) {
        v = h();
        const sl = v.slice();
        out.push(sl);
        len += v.length;
      }
      return concatBytes3(...out);
    };
    const genUntil = (seed, pred) => {
      reset2();
      reseed(seed);
      let res = void 0;
      while (!(res = pred(gen2())))
        reseed();
      reset2();
      return res;
    };
    return genUntil;
  }
  function validateObject(object, validators, optValidators = {}) {
    const checkField = (fieldName, type, isOptional) => {
      const checkVal = validatorFns[type];
      if (typeof checkVal !== "function")
        throw new Error(`Invalid validator "${type}", expected function`);
      const val = object[fieldName];
      if (isOptional && val === void 0)
        return;
      if (!checkVal(val, object)) {
        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
      }
    };
    for (const [fieldName, type] of Object.entries(validators))
      checkField(fieldName, type, false);
    for (const [fieldName, type] of Object.entries(optValidators))
      checkField(fieldName, type, true);
    return object;
  }
  function memoized(fn) {
    const map = /* @__PURE__ */ new WeakMap();
    return (arg, ...args) => {
      const val = map.get(arg);
      if (val !== void 0)
        return val;
      const computed = fn(arg, ...args);
      map.set(arg, computed);
      return computed;
    };
  }
  var _0n2, _1n2, _2n2, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns, notImplemented;
  var init_utils4 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js"() {
      _0n2 = /* @__PURE__ */ BigInt(0);
      _1n2 = /* @__PURE__ */ BigInt(1);
      _2n2 = /* @__PURE__ */ BigInt(2);
      hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
      asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
      isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
      bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
      u8n = (data) => new Uint8Array(data);
      u8fr = (arr) => Uint8Array.from(arr);
      validatorFns = {
        bigint: (val) => typeof val === "bigint",
        function: (val) => typeof val === "function",
        boolean: (val) => typeof val === "boolean",
        string: (val) => typeof val === "string",
        stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
        isSafeInteger: (val) => Number.isSafeInteger(val),
        array: (val) => Array.isArray(val),
        field: (val, object) => object.Fp.isValid(val),
        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
      };
      notImplemented = () => {
        throw new Error("not implemented");
      };
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
  function mod(a, b) {
    const result = a % b;
    return result >= _0n3 ? result : b + result;
  }
  function pow(num2, power, modulo) {
    if (modulo <= _0n3 || power < _0n3)
      throw new Error("Expected power/modulo > 0");
    if (modulo === _1n3)
      return _0n3;
    let res = _1n3;
    while (power > _0n3) {
      if (power & _1n3)
        res = res * num2 % modulo;
      num2 = num2 * num2 % modulo;
      power >>= _1n3;
    }
    return res;
  }
  function pow2(x, power, modulo) {
    let res = x;
    while (power-- > _0n3) {
      res *= res;
      res %= modulo;
    }
    return res;
  }
  function invert(number2, modulo) {
    if (number2 === _0n3 || modulo <= _0n3) {
      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
    }
    let a = mod(number2, modulo);
    let b = modulo;
    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
    while (a !== _0n3) {
      const q = b / a;
      const r = b % a;
      const m = x - u * q;
      const n = y - v * q;
      b = a, a = r, x = u, y = v, u = m, v = n;
    }
    const gcd = b;
    if (gcd !== _1n3)
      throw new Error("invert: does not exist");
    return mod(x, modulo);
  }
  function tonelliShanks(P) {
    const legendreC = (P - _1n3) / _2n3;
    let Q, S, Z;
    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
      ;
    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
      ;
    if (S === 1) {
      const p1div4 = (P + _1n3) / _4n;
      return function tonelliFast(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    const Q1div2 = (Q + _1n3) / _2n3;
    return function tonelliSlow(Fp2, n) {
      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
        throw new Error("Cannot find square root");
      let r = S;
      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
      let x = Fp2.pow(n, Q1div2);
      let b = Fp2.pow(n, Q);
      while (!Fp2.eql(b, Fp2.ONE)) {
        if (Fp2.eql(b, Fp2.ZERO))
          return Fp2.ZERO;
        let m = 1;
        for (let t2 = Fp2.sqr(b); m < r; m++) {
          if (Fp2.eql(t2, Fp2.ONE))
            break;
          t2 = Fp2.sqr(t2);
        }
        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
        g = Fp2.sqr(ge);
        x = Fp2.mul(x, ge);
        b = Fp2.mul(b, g);
        r = m;
      }
      return x;
    };
  }
  function FpSqrt(P) {
    if (P % _4n === _3n) {
      const p1div4 = (P + _1n3) / _4n;
      return function sqrt3mod4(Fp2, n) {
        const root2 = Fp2.pow(n, p1div4);
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _8n === _5n) {
      const c1 = (P - _5n) / _8n;
      return function sqrt5mod8(Fp2, n) {
        const n2 = Fp2.mul(n, _2n3);
        const v = Fp2.pow(n2, c1);
        const nv = Fp2.mul(n, v);
        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
        const root2 = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
        if (!Fp2.eql(Fp2.sqr(root2), n))
          throw new Error("Cannot find square root");
        return root2;
      };
    }
    if (P % _16n === _9n) {
    }
    return tonelliShanks(P);
  }
  function validateField(field) {
    const initial = {
      ORDER: "bigint",
      MASK: "bigint",
      BYTES: "isSafeInteger",
      BITS: "isSafeInteger"
    };
    const opts = FIELD_FIELDS.reduce((map, val) => {
      map[val] = "function";
      return map;
    }, initial);
    return validateObject(field, opts);
  }
  function FpPow(f2, num2, power) {
    if (power < _0n3)
      throw new Error("Expected power > 0");
    if (power === _0n3)
      return f2.ONE;
    if (power === _1n3)
      return num2;
    let p = f2.ONE;
    let d = num2;
    while (power > _0n3) {
      if (power & _1n3)
        p = f2.mul(p, d);
      d = f2.sqr(d);
      power >>= _1n3;
    }
    return p;
  }
  function FpInvertBatch(f2, nums) {
    const tmp = new Array(nums.length);
    const lastMultiplied = nums.reduce((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = acc;
      return f2.mul(acc, num2);
    }, f2.ONE);
    const inverted = f2.inv(lastMultiplied);
    nums.reduceRight((acc, num2, i) => {
      if (f2.is0(num2))
        return acc;
      tmp[i] = f2.mul(acc, tmp[i]);
      return f2.mul(acc, num2);
    }, inverted);
    return tmp;
  }
  function nLength(n, nBitLength) {
    const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
    const nByteLength = Math.ceil(_nBitLength / 8);
    return { nBitLength: _nBitLength, nByteLength };
  }
  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
    if (ORDER <= _0n3)
      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
    if (BYTES > 2048)
      throw new Error("Field lengths over 2048 bytes are not supported");
    const sqrtP = FpSqrt(ORDER);
    const f2 = Object.freeze({
      ORDER,
      BITS,
      BYTES,
      MASK: bitMask(BITS),
      ZERO: _0n3,
      ONE: _1n3,
      create: (num2) => mod(num2, ORDER),
      isValid: (num2) => {
        if (typeof num2 !== "bigint")
          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
        return _0n3 <= num2 && num2 < ORDER;
      },
      is0: (num2) => num2 === _0n3,
      isOdd: (num2) => (num2 & _1n3) === _1n3,
      neg: (num2) => mod(-num2, ORDER),
      eql: (lhs, rhs) => lhs === rhs,
      sqr: (num2) => mod(num2 * num2, ORDER),
      add: (lhs, rhs) => mod(lhs + rhs, ORDER),
      sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
      mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
      pow: (num2, power) => FpPow(f2, num2, power),
      div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
      // Same as above, but doesn't normalize
      sqrN: (num2) => num2 * num2,
      addN: (lhs, rhs) => lhs + rhs,
      subN: (lhs, rhs) => lhs - rhs,
      mulN: (lhs, rhs) => lhs * rhs,
      inv: (num2) => invert(num2, ORDER),
      sqrt: redef.sqrt || ((n) => sqrtP(f2, n)),
      invertBatch: (lst) => FpInvertBatch(f2, lst),
      // TODO: do we really need constant cmov?
      // We don't have const-time bigints anyway, so probably will be not very useful
      cmov: (a, b, c) => c ? b : a,
      toBytes: (num2) => isLE2 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
      fromBytes: (bytes2) => {
        if (bytes2.length !== BYTES)
          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
      }
    });
    return Object.freeze(f2);
  }
  function getFieldBytesLength(fieldOrder) {
    if (typeof fieldOrder !== "bigint")
      throw new Error("field order must be bigint");
    const bitLength = fieldOrder.toString(2).length;
    return Math.ceil(bitLength / 8);
  }
  function getMinHashLength(fieldOrder) {
    const length = getFieldBytesLength(fieldOrder);
    return length + Math.ceil(length / 2);
  }
  function mapHashToField(key, fieldOrder, isLE2 = false) {
    const len = key.length;
    const fieldLen = getFieldBytesLength(fieldOrder);
    const minLen = getMinHashLength(fieldOrder);
    if (len < 16 || len < minLen || len > 1024)
      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
    const num2 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
    const reduced = mod(num2, fieldOrder - _1n3) + _1n3;
    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
  }
  var _0n3, _1n3, _2n3, _3n, _4n, _5n, _8n, _9n, _16n, FIELD_FIELDS;
  var init_modular = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js"() {
      init_utils4();
      _0n3 = BigInt(0);
      _1n3 = BigInt(1);
      _2n3 = BigInt(2);
      _3n = BigInt(3);
      _4n = BigInt(4);
      _5n = BigInt(5);
      _8n = BigInt(8);
      _9n = BigInt(9);
      _16n = BigInt(16);
      FIELD_FIELDS = [
        "create",
        "isValid",
        "is0",
        "neg",
        "inv",
        "sqrt",
        "sqr",
        "eql",
        "add",
        "sub",
        "mul",
        "pow",
        "div",
        "addN",
        "subN",
        "mulN",
        "sqrN"
      ];
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
  function wNAF(c, bits) {
    const constTimeNegate = (condition, item) => {
      const neg = item.negate();
      return condition ? neg : item;
    };
    const validateW = (W) => {
      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
    };
    const opts = (W) => {
      validateW(W);
      const windows = Math.ceil(bits / W) + 1;
      const windowSize = 2 ** (W - 1);
      return { windows, windowSize };
    };
    return {
      constTimeNegate,
      // non-const time multiplication ladder
      unsafeLadder(elm, n) {
        let p = c.ZERO;
        let d = elm;
        while (n > _0n4) {
          if (n & _1n4)
            p = p.add(d);
          d = d.double();
          n >>= _1n4;
        }
        return p;
      },
      /**
       * Creates a wNAF precomputation window. Used for caching.
       * Default window size is set by `utils.precompute()` and is equal to 8.
       * Number of precomputed points depends on the curve size:
       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
       * - 𝑊 is the window size
       * - 𝑛 is the bitlength of the curve order.
       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
       * @returns precomputed point tables flattened to a single array
       */
      precomputeWindow(elm, W) {
        const { windows, windowSize } = opts(W);
        const points = [];
        let p = elm;
        let base2 = p;
        for (let window2 = 0; window2 < windows; window2++) {
          base2 = p;
          points.push(base2);
          for (let i = 1; i < windowSize; i++) {
            base2 = base2.add(p);
            points.push(base2);
          }
          p = base2.double();
        }
        return points;
      },
      /**
       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
       * @param W window size
       * @param precomputes precomputed tables
       * @param n scalar (we don't check here, but should be less than curve order)
       * @returns real and fake (for const-time) points
       */
      wNAF(W, precomputes, n) {
        const { windows, windowSize } = opts(W);
        let p = c.ZERO;
        let f2 = c.BASE;
        const mask = BigInt(2 ** W - 1);
        const maxNumber = 2 ** W;
        const shiftBy = BigInt(W);
        for (let window2 = 0; window2 < windows; window2++) {
          const offset = window2 * windowSize;
          let wbits = Number(n & mask);
          n >>= shiftBy;
          if (wbits > windowSize) {
            wbits -= maxNumber;
            n += _1n4;
          }
          const offset1 = offset;
          const offset2 = offset + Math.abs(wbits) - 1;
          const cond1 = window2 % 2 !== 0;
          const cond2 = wbits < 0;
          if (wbits === 0) {
            f2 = f2.add(constTimeNegate(cond1, precomputes[offset1]));
          } else {
            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
          }
        }
        return { p, f: f2 };
      },
      wNAFCached(P, n, transform) {
        const W = pointWindowSizes.get(P) || 1;
        let comp = pointPrecomputes.get(P);
        if (!comp) {
          comp = this.precomputeWindow(P, W);
          if (W !== 1)
            pointPrecomputes.set(P, transform(comp));
        }
        return this.wNAF(W, comp, n);
      },
      // We calculate precomputes for elliptic curve point multiplication
      // using windowed method. This specifies window size and
      // stores precomputed values. Usually only base point would be precomputed.
      setWindowSize(P, W) {
        validateW(W);
        pointWindowSizes.set(P, W);
        pointPrecomputes.delete(P);
      }
    };
  }
  function pippenger(c, field, points, scalars) {
    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
      throw new Error("arrays of points and scalars must have equal length");
    scalars.forEach((s, i) => {
      if (!field.isValid(s))
        throw new Error(`wrong scalar at index ${i}`);
    });
    points.forEach((p, i) => {
      if (!(p instanceof c))
        throw new Error(`wrong point at index ${i}`);
    });
    const wbits = bitLen(BigInt(points.length));
    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
    const MASK = (1 << windowSize) - 1;
    const buckets = new Array(MASK + 1).fill(c.ZERO);
    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
    let sum = c.ZERO;
    for (let i = lastBits; i >= 0; i -= windowSize) {
      buckets.fill(c.ZERO);
      for (let j = 0; j < scalars.length; j++) {
        const scalar = scalars[j];
        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
        buckets[wbits2] = buckets[wbits2].add(points[j]);
      }
      let resI = c.ZERO;
      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
        sumI = sumI.add(buckets[j]);
        resI = resI.add(sumI);
      }
      sum = sum.add(resI);
      if (i !== 0)
        for (let j = 0; j < windowSize; j++)
          sum = sum.double();
    }
    return sum;
  }
  function validateBasic(curve) {
    validateField(curve.Fp);
    validateObject(curve, {
      n: "bigint",
      h: "bigint",
      Gx: "field",
      Gy: "field"
    }, {
      nBitLength: "isSafeInteger",
      nByteLength: "isSafeInteger"
    });
    return Object.freeze({
      ...nLength(curve.n, curve.nBitLength),
      ...curve,
      ...{ p: curve.Fp.ORDER }
    });
  }
  var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
  var init_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js"() {
      init_modular();
      init_utils4();
      _0n4 = BigInt(0);
      _1n4 = BigInt(1);
      pointPrecomputes = /* @__PURE__ */ new WeakMap();
      pointWindowSizes = /* @__PURE__ */ new WeakMap();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
  function validateSigVerOpts(opts) {
    if (opts.lowS !== void 0)
      abool("lowS", opts.lowS);
    if (opts.prehash !== void 0)
      abool("prehash", opts.prehash);
  }
  function validatePointOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      a: "field",
      b: "field"
    }, {
      allowedPrivateKeyLengths: "array",
      wrapPrivateKey: "boolean",
      isTorsionFree: "function",
      clearCofactor: "function",
      allowInfinityPoint: "boolean",
      fromBytes: "function",
      toBytes: "function"
    });
    const { endo, Fp: Fp2, a } = opts;
    if (endo) {
      if (!Fp2.eql(a, Fp2.ZERO)) {
        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
      }
      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
      }
    }
    return Object.freeze({ ...opts });
  }
  function weierstrassPoints(opts) {
    const CURVE = validatePointOpts(opts);
    const { Fp: Fp2 } = CURVE;
    const Fn = Field(CURVE.n, CURVE.nBitLength);
    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
      const a = point.toAffine();
      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
    });
    const fromBytes2 = CURVE.fromBytes || ((bytes2) => {
      const tail = bytes2.subarray(1);
      const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
      const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
      return { x, y };
    });
    function weierstrassEquation(x) {
      const { a, b } = CURVE;
      const x2 = Fp2.sqr(x);
      const x3 = Fp2.mul(x2, x);
      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
    }
    if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
      throw new Error("bad generator point: equation left != right");
    function isWithinCurveOrder(num2) {
      return inRange(num2, _1n5, CURVE.n);
    }
    function normPrivateKeyToScalar(key) {
      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
      if (lengths && typeof key !== "bigint") {
        if (isBytes2(key))
          key = bytesToHex2(key);
        if (typeof key !== "string" || !lengths.includes(key.length))
          throw new Error("Invalid key");
        key = key.padStart(nByteLength * 2, "0");
      }
      let num2;
      try {
        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
      } catch (error) {
        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
      }
      if (wrapPrivateKey)
        num2 = mod(num2, N);
      aInRange("private key", num2, _1n5, N);
      return num2;
    }
    function assertPrjPoint(other) {
      if (!(other instanceof Point2))
        throw new Error("ProjectivePoint expected");
    }
    const toAffineMemo = memoized((p, iz) => {
      const { px: x, py: y, pz: z } = p;
      if (Fp2.eql(z, Fp2.ONE))
        return { x, y };
      const is0 = p.is0();
      if (iz == null)
        iz = is0 ? Fp2.ONE : Fp2.inv(z);
      const ax = Fp2.mul(x, iz);
      const ay = Fp2.mul(y, iz);
      const zz = Fp2.mul(z, iz);
      if (is0)
        return { x: Fp2.ZERO, y: Fp2.ZERO };
      if (!Fp2.eql(zz, Fp2.ONE))
        throw new Error("invZ was invalid");
      return { x: ax, y: ay };
    });
    const assertValidMemo = memoized((p) => {
      if (p.is0()) {
        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
          return;
        throw new Error("bad point: ZERO");
      }
      const { x, y } = p.toAffine();
      if (!Fp2.isValid(x) || !Fp2.isValid(y))
        throw new Error("bad point: x or y not FE");
      const left = Fp2.sqr(y);
      const right = weierstrassEquation(x);
      if (!Fp2.eql(left, right))
        throw new Error("bad point: equation left != right");
      if (!p.isTorsionFree())
        throw new Error("bad point: not in prime-order subgroup");
      return true;
    });
    class Point2 {
      constructor(px, py, pz) {
        this.px = px;
        this.py = py;
        this.pz = pz;
        if (px == null || !Fp2.isValid(px))
          throw new Error("x required");
        if (py == null || !Fp2.isValid(py))
          throw new Error("y required");
        if (pz == null || !Fp2.isValid(pz))
          throw new Error("z required");
        Object.freeze(this);
      }
      // Does not validate if the point is on-curve.
      // Use fromHex instead, or call assertValidity() later.
      static fromAffine(p) {
        const { x, y } = p || {};
        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
          throw new Error("invalid affine point");
        if (p instanceof Point2)
          throw new Error("projective point not allowed");
        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
        if (is0(x) && is0(y))
          return Point2.ZERO;
        return new Point2(x, y, Fp2.ONE);
      }
      get x() {
        return this.toAffine().x;
      }
      get y() {
        return this.toAffine().y;
      }
      /**
       * Takes a bunch of Projective Points but executes only one
       * inversion on all of them. Inversion is very slow operation,
       * so this improves performance massively.
       * Optimization: converts a list of projective points to a list of identical points with Z=1.
       */
      static normalizeZ(points) {
        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
        return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
      }
      /**
       * Converts hash string or Uint8Array to Point.
       * @param hex short/long ECDSA hex
       */
      static fromHex(hex) {
        const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
        P.assertValidity();
        return P;
      }
      // Multiplies generator point by privateKey.
      static fromPrivateKey(privateKey) {
        return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
      }
      // Multiscalar Multiplication
      static msm(points, scalars) {
        return pippenger(Point2, Fn, points, scalars);
      }
      // "Private method", don't use it directly
      _setWindowSize(windowSize) {
        wnaf.setWindowSize(this, windowSize);
      }
      // A point on curve is valid if it conforms to equation.
      assertValidity() {
        assertValidMemo(this);
      }
      hasEvenY() {
        const { y } = this.toAffine();
        if (Fp2.isOdd)
          return !Fp2.isOdd(y);
        throw new Error("Field doesn't support isOdd");
      }
      /**
       * Compare one point to another.
       */
      equals(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
        return U1 && U2;
      }
      /**
       * Flips point to one corresponding to (x, -y) in Affine coordinates.
       */
      negate() {
        return new Point2(this.px, Fp2.neg(this.py), this.pz);
      }
      // Renes-Costello-Batina exception-free doubling formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 3
      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
      double() {
        const { a, b } = CURVE;
        const b32 = Fp2.mul(b, _3n2);
        const { px: X1, py: Y1, pz: Z1 } = this;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        let t0 = Fp2.mul(X1, X1);
        let t1 = Fp2.mul(Y1, Y1);
        let t2 = Fp2.mul(Z1, Z1);
        let t3 = Fp2.mul(X1, Y1);
        t3 = Fp2.add(t3, t3);
        Z3 = Fp2.mul(X1, Z1);
        Z3 = Fp2.add(Z3, Z3);
        X3 = Fp2.mul(a, Z3);
        Y3 = Fp2.mul(b32, t2);
        Y3 = Fp2.add(X3, Y3);
        X3 = Fp2.sub(t1, Y3);
        Y3 = Fp2.add(t1, Y3);
        Y3 = Fp2.mul(X3, Y3);
        X3 = Fp2.mul(t3, X3);
        Z3 = Fp2.mul(b32, Z3);
        t2 = Fp2.mul(a, t2);
        t3 = Fp2.sub(t0, t2);
        t3 = Fp2.mul(a, t3);
        t3 = Fp2.add(t3, Z3);
        Z3 = Fp2.add(t0, t0);
        t0 = Fp2.add(Z3, t0);
        t0 = Fp2.add(t0, t2);
        t0 = Fp2.mul(t0, t3);
        Y3 = Fp2.add(Y3, t0);
        t2 = Fp2.mul(Y1, Z1);
        t2 = Fp2.add(t2, t2);
        t0 = Fp2.mul(t2, t3);
        X3 = Fp2.sub(X3, t0);
        Z3 = Fp2.mul(t2, t1);
        Z3 = Fp2.add(Z3, Z3);
        Z3 = Fp2.add(Z3, Z3);
        return new Point2(X3, Y3, Z3);
      }
      // Renes-Costello-Batina exception-free addition formula.
      // There is 30% faster Jacobian formula, but it is not complete.
      // https://eprint.iacr.org/2015/1060, algorithm 1
      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
      add(other) {
        assertPrjPoint(other);
        const { px: X1, py: Y1, pz: Z1 } = this;
        const { px: X2, py: Y2, pz: Z2 } = other;
        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
        const a = CURVE.a;
        const b32 = Fp2.mul(CURVE.b, _3n2);
        let t0 = Fp2.mul(X1, X2);
        let t1 = Fp2.mul(Y1, Y2);
        let t2 = Fp2.mul(Z1, Z2);
        let t3 = Fp2.add(X1, Y1);
        let t4 = Fp2.add(X2, Y2);
        t3 = Fp2.mul(t3, t4);
        t4 = Fp2.add(t0, t1);
        t3 = Fp2.sub(t3, t4);
        t4 = Fp2.add(X1, Z1);
        let t5 = Fp2.add(X2, Z2);
        t4 = Fp2.mul(t4, t5);
        t5 = Fp2.add(t0, t2);
        t4 = Fp2.sub(t4, t5);
        t5 = Fp2.add(Y1, Z1);
        X3 = Fp2.add(Y2, Z2);
        t5 = Fp2.mul(t5, X3);
        X3 = Fp2.add(t1, t2);
        t5 = Fp2.sub(t5, X3);
        Z3 = Fp2.mul(a, t4);
        X3 = Fp2.mul(b32, t2);
        Z3 = Fp2.add(X3, Z3);
        X3 = Fp2.sub(t1, Z3);
        Z3 = Fp2.add(t1, Z3);
        Y3 = Fp2.mul(X3, Z3);
        t1 = Fp2.add(t0, t0);
        t1 = Fp2.add(t1, t0);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.mul(b32, t4);
        t1 = Fp2.add(t1, t2);
        t2 = Fp2.sub(t0, t2);
        t2 = Fp2.mul(a, t2);
        t4 = Fp2.add(t4, t2);
        t0 = Fp2.mul(t1, t4);
        Y3 = Fp2.add(Y3, t0);
        t0 = Fp2.mul(t5, t4);
        X3 = Fp2.mul(t3, X3);
        X3 = Fp2.sub(X3, t0);
        t0 = Fp2.mul(t3, t1);
        Z3 = Fp2.mul(t5, Z3);
        Z3 = Fp2.add(Z3, t0);
        return new Point2(X3, Y3, Z3);
      }
      subtract(other) {
        return this.add(other.negate());
      }
      is0() {
        return this.equals(Point2.ZERO);
      }
      wNAF(n) {
        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
      }
      /**
       * Non-constant-time multiplication. Uses double-and-add algorithm.
       * It's faster, but should only be used when you don't care about
       * an exposed private key e.g. sig verification, which works over *public* keys.
       */
      multiplyUnsafe(sc) {
        aInRange("scalar", sc, _0n5, CURVE.n);
        const I = Point2.ZERO;
        if (sc === _0n5)
          return I;
        if (sc === _1n5)
          return this;
        const { endo } = CURVE;
        if (!endo)
          return wnaf.unsafeLadder(this, sc);
        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
        let k1p = I;
        let k2p = I;
        let d = this;
        while (k1 > _0n5 || k2 > _0n5) {
          if (k1 & _1n5)
            k1p = k1p.add(d);
          if (k2 & _1n5)
            k2p = k2p.add(d);
          d = d.double();
          k1 >>= _1n5;
          k2 >>= _1n5;
        }
        if (k1neg)
          k1p = k1p.negate();
        if (k2neg)
          k2p = k2p.negate();
        k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
        return k1p.add(k2p);
      }
      /**
       * Constant time multiplication.
       * Uses wNAF method. Windowed method may be 10% faster,
       * but takes 2x longer to generate and consumes 2x memory.
       * Uses precomputes when available.
       * Uses endomorphism for Koblitz curves.
       * @param scalar by which the point would be multiplied
       * @returns New point
       */
      multiply(scalar) {
        const { endo, n: N } = CURVE;
        aInRange("scalar", scalar, _1n5, N);
        let point, fake;
        if (endo) {
          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
          let { p: k1p, f: f1p } = this.wNAF(k1);
          let { p: k2p, f: f2p } = this.wNAF(k2);
          k1p = wnaf.constTimeNegate(k1neg, k1p);
          k2p = wnaf.constTimeNegate(k2neg, k2p);
          k2p = new Point2(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
          point = k1p.add(k2p);
          fake = f1p.add(f2p);
        } else {
          const { p, f: f2 } = this.wNAF(scalar);
          point = p;
          fake = f2;
        }
        return Point2.normalizeZ([point, fake])[0];
      }
      /**
       * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
       * Not using Strauss-Shamir trick: precomputation tables are faster.
       * The trick could be useful if both P and Q are not G (not in our case).
       * @returns non-zero affine point
       */
      multiplyAndAddUnsafe(Q, a, b) {
        const G = Point2.BASE;
        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
        const sum = mul(this, a).add(mul(Q, b));
        return sum.is0() ? void 0 : sum;
      }
      // Converts Projective point to affine (x, y) coordinates.
      // Can accept precomputed Z^-1 - for example, from invertBatch.
      // (x, y, z) ∋ (x=x/z, y=y/z)
      toAffine(iz) {
        return toAffineMemo(this, iz);
      }
      isTorsionFree() {
        const { h: cofactor, isTorsionFree } = CURVE;
        if (cofactor === _1n5)
          return true;
        if (isTorsionFree)
          return isTorsionFree(Point2, this);
        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
      }
      clearCofactor() {
        const { h: cofactor, clearCofactor } = CURVE;
        if (cofactor === _1n5)
          return this;
        if (clearCofactor)
          return clearCofactor(Point2, this);
        return this.multiplyUnsafe(CURVE.h);
      }
      toRawBytes(isCompressed = true) {
        abool("isCompressed", isCompressed);
        this.assertValidity();
        return toBytes3(Point2, this, isCompressed);
      }
      toHex(isCompressed = true) {
        abool("isCompressed", isCompressed);
        return bytesToHex2(this.toRawBytes(isCompressed));
      }
    }
    Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
    const _bits = CURVE.nBitLength;
    const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
    return {
      CURVE,
      ProjectivePoint: Point2,
      normPrivateKeyToScalar,
      weierstrassEquation,
      isWithinCurveOrder
    };
  }
  function validateOpts(curve) {
    const opts = validateBasic(curve);
    validateObject(opts, {
      hash: "hash",
      hmac: "function",
      randomBytes: "function"
    }, {
      bits2int: "function",
      bits2int_modN: "function",
      lowS: "boolean"
    });
    return Object.freeze({ lowS: true, ...opts });
  }
  function weierstrass(curveDef) {
    const CURVE = validateOpts(curveDef);
    const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
    const compressedLen = Fp2.BYTES + 1;
    const uncompressedLen = 2 * Fp2.BYTES + 1;
    function modN2(a) {
      return mod(a, CURVE_ORDER);
    }
    function invN(a) {
      return invert(a, CURVE_ORDER);
    }
    const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
      ...CURVE,
      toBytes(_c, point, isCompressed) {
        const a = point.toAffine();
        const x = Fp2.toBytes(a.x);
        const cat = concatBytes3;
        abool("isCompressed", isCompressed);
        if (isCompressed) {
          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
        } else {
          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
        }
      },
      fromBytes(bytes2) {
        const len = bytes2.length;
        const head = bytes2[0];
        const tail = bytes2.subarray(1);
        if (len === compressedLen && (head === 2 || head === 3)) {
          const x = bytesToNumberBE(tail);
          if (!inRange(x, _1n5, Fp2.ORDER))
            throw new Error("Point is not on curve");
          const y2 = weierstrassEquation(x);
          let y;
          try {
            y = Fp2.sqrt(y2);
          } catch (sqrtError) {
            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
            throw new Error("Point is not on curve" + suffix);
          }
          const isYOdd = (y & _1n5) === _1n5;
          const isHeadOdd = (head & 1) === 1;
          if (isHeadOdd !== isYOdd)
            y = Fp2.neg(y);
          return { x, y };
        } else if (len === uncompressedLen && head === 4) {
          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
          return { x, y };
        } else {
          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
        }
      }
    });
    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE(num2, CURVE.nByteLength));
    function isBiggerThanHalfOrder(number2) {
      const HALF = CURVE_ORDER >> _1n5;
      return number2 > HALF;
    }
    function normalizeS(s) {
      return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
    }
    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
    class Signature {
      constructor(r, s, recovery) {
        this.r = r;
        this.s = s;
        this.recovery = recovery;
        this.assertValidity();
      }
      // pair (bytes of r, bytes of s)
      static fromCompact(hex) {
        const l = CURVE.nByteLength;
        hex = ensureBytes("compactSignature", hex, l * 2);
        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
      }
      // DER encoded ECDSA signature
      // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
      static fromDER(hex) {
        const { r, s } = DER.toSig(ensureBytes("DER", hex));
        return new Signature(r, s);
      }
      assertValidity() {
        aInRange("r", this.r, _1n5, CURVE_ORDER);
        aInRange("s", this.s, _1n5, CURVE_ORDER);
      }
      addRecoveryBit(recovery) {
        return new Signature(this.r, this.s, recovery);
      }
      recoverPublicKey(msgHash) {
        const { r, s, recovery: rec } = this;
        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
        if (rec == null || ![0, 1, 2, 3].includes(rec))
          throw new Error("recovery id invalid");
        const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
        if (radj >= Fp2.ORDER)
          throw new Error("recovery id 2 or 3 invalid");
        const prefix = (rec & 1) === 0 ? "02" : "03";
        const R = Point2.fromHex(prefix + numToNByteStr(radj));
        const ir = invN(radj);
        const u1 = modN2(-h * ir);
        const u2 = modN2(s * ir);
        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
        if (!Q)
          throw new Error("point at infinify");
        Q.assertValidity();
        return Q;
      }
      // Signatures should be low-s, to prevent malleability.
      hasHighS() {
        return isBiggerThanHalfOrder(this.s);
      }
      normalizeS() {
        return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
      }
      // DER-encoded
      toDERRawBytes() {
        return hexToBytes2(this.toDERHex());
      }
      toDERHex() {
        return DER.hexFromSig({ r: this.r, s: this.s });
      }
      // padded bytes of r, then padded bytes of s
      toCompactRawBytes() {
        return hexToBytes2(this.toCompactHex());
      }
      toCompactHex() {
        return numToNByteStr(this.r) + numToNByteStr(this.s);
      }
    }
    const utils = {
      isValidPrivateKey(privateKey) {
        try {
          normPrivateKeyToScalar(privateKey);
          return true;
        } catch (error) {
          return false;
        }
      },
      normPrivateKeyToScalar,
      /**
       * Produces cryptographically secure private key from random of size
       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
       */
      randomPrivateKey: () => {
        const length = getMinHashLength(CURVE.n);
        return mapHashToField(CURVE.randomBytes(length), CURVE.n);
      },
      /**
       * Creates precompute table for an arbitrary EC point. Makes point "cached".
       * Allows to massively speed-up `point.multiply(scalar)`.
       * @returns cached point
       * @example
       * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
       * fast.multiply(privKey); // much faster ECDH now
       */
      precompute(windowSize = 8, point = Point2.BASE) {
        point._setWindowSize(windowSize);
        point.multiply(BigInt(3));
        return point;
      }
    };
    function getPublicKey(privateKey, isCompressed = true) {
      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
    }
    function isProbPub(item) {
      const arr = isBytes2(item);
      const str = typeof item === "string";
      const len = (arr || str) && item.length;
      if (arr)
        return len === compressedLen || len === uncompressedLen;
      if (str)
        return len === 2 * compressedLen || len === 2 * uncompressedLen;
      if (item instanceof Point2)
        return true;
      return false;
    }
    function getSharedSecret(privateA, publicB, isCompressed = true) {
      if (isProbPub(privateA))
        throw new Error("first arg must be private key");
      if (!isProbPub(publicB))
        throw new Error("second arg must be public key");
      const b = Point2.fromHex(publicB);
      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
    }
    const bits2int = CURVE.bits2int || function(bytes2) {
      const num2 = bytesToNumberBE(bytes2);
      const delta = bytes2.length * 8 - CURVE.nBitLength;
      return delta > 0 ? num2 >> BigInt(delta) : num2;
    };
    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
      return modN2(bits2int(bytes2));
    };
    const ORDER_MASK = bitMask(CURVE.nBitLength);
    function int2octets(num2) {
      aInRange(`num < 2^${CURVE.nBitLength}`, num2, _0n5, ORDER_MASK);
      return numberToBytesBE(num2, CURVE.nByteLength);
    }
    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
      if (["recovered", "canonical"].some((k) => k in opts))
        throw new Error("sign() legacy options not supported");
      const { hash: hash3, randomBytes: randomBytes2 } = CURVE;
      let { lowS, prehash, extraEntropy: ent } = opts;
      if (lowS == null)
        lowS = true;
      msgHash = ensureBytes("msgHash", msgHash);
      validateSigVerOpts(opts);
      if (prehash)
        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
      const h1int = bits2int_modN(msgHash);
      const d = normPrivateKeyToScalar(privateKey);
      const seedArgs = [int2octets(d), int2octets(h1int)];
      if (ent != null && ent !== false) {
        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
        seedArgs.push(ensureBytes("extraEntropy", e));
      }
      const seed = concatBytes3(...seedArgs);
      const m = h1int;
      function k2sig(kBytes) {
        const k = bits2int(kBytes);
        if (!isWithinCurveOrder(k))
          return;
        const ik = invN(k);
        const q = Point2.BASE.multiply(k).toAffine();
        const r = modN2(q.x);
        if (r === _0n5)
          return;
        const s = modN2(ik * modN2(m + r * d));
        if (s === _0n5)
          return;
        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
        let normS = s;
        if (lowS && isBiggerThanHalfOrder(s)) {
          normS = normalizeS(s);
          recovery ^= 1;
        }
        return new Signature(r, normS, recovery);
      }
      return { seed, k2sig };
    }
    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
    function sign2(msgHash, privKey, opts = defaultSigOpts) {
      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
      const C = CURVE;
      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
      return drbg(seed, k2sig);
    }
    Point2.BASE._setWindowSize(8);
    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
      const sg = signature;
      msgHash = ensureBytes("msgHash", msgHash);
      publicKey = ensureBytes("publicKey", publicKey);
      if ("strict" in opts)
        throw new Error("options.strict was renamed to lowS");
      validateSigVerOpts(opts);
      const { lowS, prehash } = opts;
      let _sig = void 0;
      let P;
      try {
        if (typeof sg === "string" || isBytes2(sg)) {
          try {
            _sig = Signature.fromDER(sg);
          } catch (derError) {
            if (!(derError instanceof DER.Err))
              throw derError;
            _sig = Signature.fromCompact(sg);
          }
        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
          const { r: r2, s: s2 } = sg;
          _sig = new Signature(r2, s2);
        } else {
          throw new Error("PARSE");
        }
        P = Point2.fromHex(publicKey);
      } catch (error) {
        if (error.message === "PARSE")
          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
        return false;
      }
      if (lowS && _sig.hasHighS())
        return false;
      if (prehash)
        msgHash = CURVE.hash(msgHash);
      const { r, s } = _sig;
      const h = bits2int_modN(msgHash);
      const is = invN(s);
      const u1 = modN2(h * is);
      const u2 = modN2(r * is);
      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
      if (!R)
        return false;
      const v = modN2(R.x);
      return v === r;
    }
    return {
      CURVE,
      getPublicKey,
      getSharedSecret,
      sign: sign2,
      verify,
      ProjectivePoint: Point2,
      Signature,
      utils
    };
  }
  function SWUFpSqrtRatio(Fp2, Z) {
    const q = Fp2.ORDER;
    let l = _0n5;
    for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
      l += _1n5;
    const c1 = l;
    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
    const c2 = (q - _1n5) / _2n_pow_c1;
    const c3 = (c2 - _1n5) / _2n4;
    const c4 = _2n_pow_c1 - _1n5;
    const c5 = _2n_pow_c1_1;
    const c6 = Fp2.pow(Z, c2);
    const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4);
    let sqrtRatio = (u, v) => {
      let tv1 = c6;
      let tv2 = Fp2.pow(v, c4);
      let tv3 = Fp2.sqr(tv2);
      tv3 = Fp2.mul(tv3, v);
      let tv5 = Fp2.mul(u, tv3);
      tv5 = Fp2.pow(tv5, c3);
      tv5 = Fp2.mul(tv5, tv2);
      tv2 = Fp2.mul(tv5, v);
      tv3 = Fp2.mul(tv5, u);
      let tv4 = Fp2.mul(tv3, tv2);
      tv5 = Fp2.pow(tv4, c5);
      let isQR = Fp2.eql(tv5, Fp2.ONE);
      tv2 = Fp2.mul(tv3, c7);
      tv5 = Fp2.mul(tv4, tv1);
      tv3 = Fp2.cmov(tv2, tv3, isQR);
      tv4 = Fp2.cmov(tv5, tv4, isQR);
      for (let i = c1; i > _1n5; i--) {
        let tv52 = i - _2n4;
        tv52 = _2n4 << tv52 - _1n5;
        let tvv5 = Fp2.pow(tv4, tv52);
        const e1 = Fp2.eql(tvv5, Fp2.ONE);
        tv2 = Fp2.mul(tv3, tv1);
        tv1 = Fp2.mul(tv1, tv1);
        tvv5 = Fp2.mul(tv4, tv1);
        tv3 = Fp2.cmov(tv2, tv3, e1);
        tv4 = Fp2.cmov(tvv5, tv4, e1);
      }
      return { isValid: isQR, value: tv3 };
    };
    if (Fp2.ORDER % _4n2 === _3n2) {
      const c12 = (Fp2.ORDER - _3n2) / _4n2;
      const c22 = Fp2.sqrt(Fp2.neg(Z));
      sqrtRatio = (u, v) => {
        let tv1 = Fp2.sqr(v);
        const tv2 = Fp2.mul(u, v);
        tv1 = Fp2.mul(tv1, tv2);
        let y1 = Fp2.pow(tv1, c12);
        y1 = Fp2.mul(y1, tv2);
        const y2 = Fp2.mul(y1, c22);
        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
        const isQR = Fp2.eql(tv3, u);
        let y = Fp2.cmov(y2, y1, isQR);
        return { isValid: isQR, value: y };
      };
    }
    return sqrtRatio;
  }
  function mapToCurveSimpleSWU(Fp2, opts) {
    validateField(Fp2);
    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
      throw new Error("mapToCurveSimpleSWU: invalid opts");
    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
    if (!Fp2.isOdd)
      throw new Error("Fp.isOdd is not implemented!");
    return (u) => {
      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
      tv1 = Fp2.sqr(u);
      tv1 = Fp2.mul(tv1, opts.Z);
      tv2 = Fp2.sqr(tv1);
      tv2 = Fp2.add(tv2, tv1);
      tv3 = Fp2.add(tv2, Fp2.ONE);
      tv3 = Fp2.mul(tv3, opts.B);
      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
      tv4 = Fp2.mul(tv4, opts.A);
      tv2 = Fp2.sqr(tv3);
      tv6 = Fp2.sqr(tv4);
      tv5 = Fp2.mul(tv6, opts.A);
      tv2 = Fp2.add(tv2, tv5);
      tv2 = Fp2.mul(tv2, tv3);
      tv6 = Fp2.mul(tv6, tv4);
      tv5 = Fp2.mul(tv6, opts.B);
      tv2 = Fp2.add(tv2, tv5);
      x = Fp2.mul(tv1, tv3);
      const { isValid, value } = sqrtRatio(tv2, tv6);
      y = Fp2.mul(tv1, u);
      y = Fp2.mul(y, value);
      x = Fp2.cmov(x, tv3, isValid);
      y = Fp2.cmov(y, value, isValid);
      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
      y = Fp2.cmov(Fp2.neg(y), y, e1);
      x = Fp2.div(x, tv4);
      return { x, y };
    };
  }
  var b2n, h2b, DER, _0n5, _1n5, _2n4, _3n2, _4n2;
  var init_weierstrass = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
      init_curve();
      init_modular();
      init_utils4();
      init_utils4();
      ({ bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports);
      DER = {
        // asn.1 DER encoding utils
        Err: class DERErr extends Error {
          constructor(m = "") {
            super(m);
          }
        },
        // Basic building block is TLV (Tag-Length-Value)
        _tlv: {
          encode: (tag, data) => {
            const { Err: E } = DER;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length & 1)
              throw new E("tlv.encode: unpadded data");
            const dataLen = data.length / 2;
            const len = numberToHexUnpadded(dataLen);
            if (len.length / 2 & 128)
              throw new E("tlv.encode: long form length too big");
            const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
          },
          // v - value, l - left bytes (unparsed)
          decode(tag, data) {
            const { Err: E } = DER;
            let pos = 0;
            if (tag < 0 || tag > 256)
              throw new E("tlv.encode: wrong tag");
            if (data.length < 2 || data[pos++] !== tag)
              throw new E("tlv.decode: wrong tlv");
            const first = data[pos++];
            const isLong = !!(first & 128);
            let length = 0;
            if (!isLong)
              length = first;
            else {
              const lenLen = first & 127;
              if (!lenLen)
                throw new E("tlv.decode(long): indefinite length not supported");
              if (lenLen > 4)
                throw new E("tlv.decode(long): byte length is too big");
              const lengthBytes = data.subarray(pos, pos + lenLen);
              if (lengthBytes.length !== lenLen)
                throw new E("tlv.decode: length bytes not complete");
              if (lengthBytes[0] === 0)
                throw new E("tlv.decode(long): zero leftmost byte");
              for (const b of lengthBytes)
                length = length << 8 | b;
              pos += lenLen;
              if (length < 128)
                throw new E("tlv.decode(long): not minimal encoding");
            }
            const v = data.subarray(pos, pos + length);
            if (v.length !== length)
              throw new E("tlv.decode: wrong value length");
            return { v, l: data.subarray(pos + length) };
          }
        },
        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
        // since we always use positive integers here. It must always be empty:
        // - add zero byte if exists
        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
        _int: {
          encode(num2) {
            const { Err: E } = DER;
            if (num2 < _0n5)
              throw new E("integer: negative integers are not allowed");
            let hex = numberToHexUnpadded(num2);
            if (Number.parseInt(hex[0], 16) & 8)
              hex = "00" + hex;
            if (hex.length & 1)
              throw new E("unexpected assertion");
            return hex;
          },
          decode(data) {
            const { Err: E } = DER;
            if (data[0] & 128)
              throw new E("Invalid signature integer: negative");
            if (data[0] === 0 && !(data[1] & 128))
              throw new E("Invalid signature integer: unnecessary leading zero");
            return b2n(data);
          }
        },
        toSig(hex) {
          const { Err: E, _int: int, _tlv: tlv } = DER;
          const data = typeof hex === "string" ? h2b(hex) : hex;
          abytes(data);
          const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
          if (seqLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
          const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
          if (sLeftBytes.length)
            throw new E("Invalid signature: left bytes after parsing");
          return { r: int.decode(rBytes), s: int.decode(sBytes) };
        },
        hexFromSig(sig) {
          const { _tlv: tlv, _int: int } = DER;
          const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
          return tlv.encode(48, seq);
        }
      };
      _0n5 = BigInt(0);
      _1n5 = BigInt(1);
      _2n4 = BigInt(2);
      _3n2 = BigInt(3);
      _4n2 = BigInt(4);
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
  function getHash(hash3) {
    return {
      hash: hash3,
      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
      randomBytes
    };
  }
  function createCurve(curveDef, defHash) {
    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
    return Object.freeze({ ...create(defHash), create });
  }
  var init_shortw_utils = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js"() {
      init_hmac();
      init_utils2();
      init_weierstrass();
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
  function i2osp(value, length) {
    anum(value);
    anum(length);
    if (value < 0 || value >= 1 << 8 * length) {
      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
    }
    const res = Array.from({ length }).fill(0);
    for (let i = length - 1; i >= 0; i--) {
      res[i] = value & 255;
      value >>>= 8;
    }
    return new Uint8Array(res);
  }
  function strxor(a, b) {
    const arr = new Uint8Array(a.length);
    for (let i = 0; i < a.length; i++) {
      arr[i] = a[i] ^ b[i];
    }
    return arr;
  }
  function anum(item) {
    if (!Number.isSafeInteger(item))
      throw new Error("number expected");
  }
  function expand_message_xmd(msg, DST, lenInBytes, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255)
      DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
    const ell = Math.ceil(lenInBytes / b_in_bytes);
    if (lenInBytes > 65535 || ell > 255)
      throw new Error("expand_message_xmd: invalid lenInBytes");
    const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
    const Z_pad = i2osp(0, r_in_bytes);
    const l_i_b_str = i2osp(lenInBytes, 2);
    const b = new Array(ell);
    const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
    b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
    for (let i = 1; i <= ell; i++) {
      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
      b[i] = H(concatBytes3(...args));
    }
    const pseudo_random_bytes = concatBytes3(...b);
    return pseudo_random_bytes.slice(0, lenInBytes);
  }
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
    abytes(msg);
    abytes(DST);
    anum(lenInBytes);
    if (DST.length > 255) {
      const dkLen = Math.ceil(2 * k / 8);
      DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
    }
    if (lenInBytes > 65535 || DST.length > 255)
      throw new Error("expand_message_xof: invalid lenInBytes");
    return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
  }
  function hash_to_field(msg, count, options) {
    validateObject(options, {
      DST: "stringOrUint8Array",
      p: "bigint",
      m: "isSafeInteger",
      k: "isSafeInteger",
      hash: "hash"
    });
    const { p, k, m, hash: hash3, expand, DST: _DST } = options;
    abytes(msg);
    anum(count);
    const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
    const log2p = p.toString(2).length;
    const L = Math.ceil((log2p + k) / 8);
    const len_in_bytes = count * m * L;
    let prb;
    if (expand === "xmd") {
      prb = expand_message_xmd(msg, DST, len_in_bytes, hash3);
    } else if (expand === "xof") {
      prb = expand_message_xof(msg, DST, len_in_bytes, k, hash3);
    } else if (expand === "_internal_pass") {
      prb = msg;
    } else {
      throw new Error('expand must be "xmd" or "xof"');
    }
    const u = new Array(count);
    for (let i = 0; i < count; i++) {
      const e = new Array(m);
      for (let j = 0; j < m; j++) {
        const elm_offset = L * (j + i * m);
        const tv = prb.subarray(elm_offset, elm_offset + L);
        e[j] = mod(os2ip(tv), p);
      }
      u[i] = e;
    }
    return u;
  }
  function isogenyMap(field, map) {
    const COEFF = map.map((i) => Array.from(i).reverse());
    return (x, y) => {
      const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
      x = field.div(xNum, xDen);
      y = field.mul(y, field.div(yNum, yDen));
      return { x, y };
    };
  }
  function createHasher(Point2, mapToCurve, def) {
    if (typeof mapToCurve !== "function")
      throw new Error("mapToCurve() must be defined");
    return {
      // Encodes byte string to elliptic curve.
      // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      hashToCurve(msg, options) {
        const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
        const u0 = Point2.fromAffine(mapToCurve(u[0]));
        const u1 = Point2.fromAffine(mapToCurve(u[1]));
        const P = u0.add(u1).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Encodes byte string to elliptic curve.
      // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
      encodeToCurve(msg, options) {
        const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
        const P = Point2.fromAffine(mapToCurve(u[0])).clearCofactor();
        P.assertValidity();
        return P;
      },
      // Same as encodeToCurve, but without hash
      mapToCurve(scalars) {
        if (!Array.isArray(scalars))
          throw new Error("mapToCurve: expected array of bigints");
        for (const i of scalars)
          if (typeof i !== "bigint")
            throw new Error(`mapToCurve: expected array of bigints, got ${i} in array`);
        const P = Point2.fromAffine(mapToCurve(scalars)).clearCofactor();
        P.assertValidity();
        return P;
      }
    };
  }
  var os2ip;
  var init_hash_to_curve = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
      init_modular();
      init_utils4();
      os2ip = bytesToNumberBE;
    }
  });

  // node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
  var secp256k1_exports = {};
  __export(secp256k1_exports, {
    encodeToCurve: () => encodeToCurve,
    hashToCurve: () => hashToCurve,
    schnorr: () => schnorr,
    secp256k1: () => secp256k1
  });
  function sqrtMod(y) {
    const P = secp256k1P;
    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
    const b2 = y * y * y % P;
    const b32 = b2 * b2 * y % P;
    const b6 = pow2(b32, _3n3, P) * b32 % P;
    const b9 = pow2(b6, _3n3, P) * b32 % P;
    const b11 = pow2(b9, _2n5, P) * b2 % P;
    const b22 = pow2(b11, _11n, P) * b11 % P;
    const b44 = pow2(b22, _22n, P) * b22 % P;
    const b88 = pow2(b44, _44n, P) * b44 % P;
    const b176 = pow2(b88, _88n, P) * b88 % P;
    const b220 = pow2(b176, _44n, P) * b44 % P;
    const b223 = pow2(b220, _3n3, P) * b32 % P;
    const t1 = pow2(b223, _23n, P) * b22 % P;
    const t2 = pow2(t1, _6n, P) * b2 % P;
    const root2 = pow2(t2, _2n5, P);
    if (!Fp.eql(Fp.sqr(root2), y))
      throw new Error("Cannot find square root");
    return root2;
  }
  function taggedHash(tag, ...messages) {
    let tagP = TAGGED_HASH_PREFIXES[tag];
    if (tagP === void 0) {
      const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
      tagP = concatBytes3(tagH, tagH);
      TAGGED_HASH_PREFIXES[tag] = tagP;
    }
    return sha256(concatBytes3(tagP, ...messages));
  }
  function schnorrGetExtPubKey(priv) {
    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
    let p = Point.fromPrivateKey(d_);
    const scalar = p.hasEvenY() ? d_ : modN(-d_);
    return { scalar, bytes: pointToBytes(p) };
  }
  function lift_x(x) {
    aInRange("x", x, _1n6, secp256k1P);
    const xx = modP(x * x);
    const c = modP(xx * x + BigInt(7));
    let y = sqrtMod(c);
    if (y % _2n5 !== _0n6)
      y = modP(-y);
    const p = new Point(x, y, _1n6);
    p.assertValidity();
    return p;
  }
  function challenge(...args) {
    return modN(num(taggedHash("BIP0340/challenge", ...args)));
  }
  function schnorrGetPublicKey(privateKey) {
    return schnorrGetExtPubKey(privateKey).bytes;
  }
  function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
    const m = ensureBytes("message", message);
    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
    const a = ensureBytes("auxRand", auxRand, 32);
    const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
    const rand = taggedHash("BIP0340/nonce", t, px, m);
    const k_ = modN(num(rand));
    if (k_ === _0n6)
      throw new Error("sign failed: k is zero");
    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
    const e = challenge(rx, px, m);
    const sig = new Uint8Array(64);
    sig.set(rx, 0);
    sig.set(numTo32b(modN(k + e * d)), 32);
    if (!schnorrVerify(sig, m, px))
      throw new Error("sign: Invalid signature produced");
    return sig;
  }
  function schnorrVerify(signature, message, publicKey) {
    const sig = ensureBytes("signature", signature, 64);
    const m = ensureBytes("message", message);
    const pub = ensureBytes("publicKey", publicKey, 32);
    try {
      const P = lift_x(num(pub));
      const r = num(sig.subarray(0, 32));
      if (!inRange(r, _1n6, secp256k1P))
        return false;
      const s = num(sig.subarray(32, 64));
      if (!inRange(s, _1n6, secp256k1N))
        return false;
      const e = challenge(numTo32b(r), pointToBytes(P), m);
      const R = GmulAdd(P, s, modN(-e));
      if (!R || !R.hasEvenY() || R.toAffine().x !== r)
        return false;
      return true;
    } catch (error) {
      return false;
    }
  }
  var secp256k1P, secp256k1N, _1n6, _2n5, divNearest, Fp, secp256k1, _0n6, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, htf, hashToCurve, encodeToCurve;
  var init_secp256k1 = __esm({
    "node_modules/.deno/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js"() {
      init_sha256();
      init_utils2();
      init_shortw_utils();
      init_hash_to_curve();
      init_modular();
      init_utils4();
      init_weierstrass();
      secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
      secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
      _1n6 = BigInt(1);
      _2n5 = BigInt(2);
      divNearest = (a, b) => (a + b / _2n5) / b;
      Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
      secp256k1 = createCurve({
        a: BigInt(0),
        // equation params: a, b
        b: BigInt(7),
        // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
        Fp,
        // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
        n: secp256k1N,
        // Curve order, total count of valid points in the field
        // Base point (x, y) aka generator point
        Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
        Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
        h: BigInt(1),
        // Cofactor
        lowS: true,
        // Allow only low-S signatures by default in sign() and verify()
        /**
         * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
         * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
         * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
         * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
         */
        endo: {
          beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
          splitScalar: (k) => {
            const n = secp256k1N;
            const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
            const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
            const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
            const b2 = a1;
            const POW_2_128 = BigInt("0x100000000000000000000000000000000");
            const c1 = divNearest(b2 * k, n);
            const c2 = divNearest(-b1 * k, n);
            let k1 = mod(k - c1 * a1 - c2 * a2, n);
            let k2 = mod(-c1 * b1 - c2 * b2, n);
            const k1neg = k1 > POW_2_128;
            const k2neg = k2 > POW_2_128;
            if (k1neg)
              k1 = n - k1;
            if (k2neg)
              k2 = n - k2;
            if (k1 > POW_2_128 || k2 > POW_2_128) {
              throw new Error("splitScalar: Endomorphism failed, k=" + k);
            }
            return { k1neg, k1, k2neg, k2 };
          }
        }
      }, sha256);
      _0n6 = BigInt(0);
      TAGGED_HASH_PREFIXES = {};
      pointToBytes = (point) => point.toRawBytes(true).slice(1);
      numTo32b = (n) => numberToBytesBE(n, 32);
      modP = (x) => mod(x, secp256k1P);
      modN = (x) => mod(x, secp256k1N);
      Point = secp256k1.ProjectivePoint;
      GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
      num = bytesToNumberBE;
      schnorr = /* @__PURE__ */ (() => ({
        getPublicKey: schnorrGetPublicKey,
        sign: schnorrSign,
        verify: schnorrVerify,
        utils: {
          randomPrivateKey: secp256k1.utils.randomPrivateKey,
          lift_x,
          pointToBytes,
          numberToBytesBE,
          bytesToNumberBE,
          taggedHash,
          mod
        }
      }))();
      isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [
        // xNum
        [
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
        ],
        // xDen
        [
          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ],
        // yNum
        [
          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
        ],
        // yDen
        [
          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
          "0x0000000000000000000000000000000000000000000000000000000000000001"
          // LAST 1
        ]
      ].map((i) => i.map((j) => BigInt(j)))))();
      mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {
        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
        B: BigInt("1771"),
        Z: Fp.create(BigInt("-11"))
      }))();
      htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
        const { x, y } = mapSWU(Fp.create(scalars[0]));
        return isoMap(x, y);
      }, {
        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
        p: Fp.ORDER,
        m: 1,
        k: 128,
        expand: "xmd",
        hash: sha256
      }))();
      hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();
      encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js
  var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError;
  var init_node = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/node.js"() {
      init_formatGwei();
      init_base();
      ExecutionRevertedError = class extends BaseError2 {
        constructor({ cause, message } = {}) {
          const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
          super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
            cause,
            name: "ExecutionRevertedError"
          });
        }
      };
      Object.defineProperty(ExecutionRevertedError, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: 3
      });
      Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /execution reverted/
      });
      FeeCapTooHighError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
            cause,
            name: "FeeCapTooHighError"
          });
        }
      };
      Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
      });
      FeeCapTooLowError = class extends BaseError2 {
        constructor({ cause, maxFeePerGas } = {}) {
          super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
            cause,
            name: "FeeCapTooLowError"
          });
        }
      };
      Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
      });
      NonceTooHighError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
        }
      };
      Object.defineProperty(NonceTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too high/
      });
      NonceTooLowError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super([
            `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
            "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
          ].join("\n"), { cause, name: "NonceTooLowError" });
        }
      };
      Object.defineProperty(NonceTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce too low|transaction already imported|already known/
      });
      NonceMaxValueError = class extends BaseError2 {
        constructor({ cause, nonce } = {}) {
          super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
        }
      };
      Object.defineProperty(NonceMaxValueError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /nonce has max value/
      });
      InsufficientFundsError = class extends BaseError2 {
        constructor({ cause } = {}) {
          super([
            "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
          ].join("\n"), {
            cause,
            metaMessages: [
              "This error could arise when the account does not have enough funds to:",
              " - pay for the total gas fee,",
              " - pay for the value to send.",
              " ",
              "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
              " - `gas` is the amount of gas needed for transaction to execute,",
              " - `gas fee` is the gas fee,",
              " - `value` is the amount of ether to send to the recipient."
            ],
            name: "InsufficientFundsError"
          });
        }
      };
      Object.defineProperty(InsufficientFundsError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /insufficient funds|exceeds transaction sender account balance/
      });
      IntrinsicGasTooHighError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
            cause,
            name: "IntrinsicGasTooHighError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too high|gas limit reached/
      });
      IntrinsicGasTooLowError = class extends BaseError2 {
        constructor({ cause, gas } = {}) {
          super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
            cause,
            name: "IntrinsicGasTooLowError"
          });
        }
      };
      Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /intrinsic gas too low/
      });
      TransactionTypeNotSupportedError = class extends BaseError2 {
        constructor({ cause }) {
          super("The transaction type is not supported for this chain.", {
            cause,
            name: "TransactionTypeNotSupportedError"
          });
        }
      };
      Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /transaction type not valid/
      });
      TipAboveFeeCapError = class extends BaseError2 {
        constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
          super([
            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
          ].join("\n"), {
            cause,
            name: "TipAboveFeeCapError"
          });
        }
      };
      Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
      });
      UnknownNodeError = class extends BaseError2 {
        constructor({ cause }) {
          super(`An error occurred while executing: ${cause?.shortMessage}`, {
            cause,
            name: "UnknownNodeError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js
  function getNodeError(err, args) {
    const message = (err.details || "").toLowerCase();
    const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
    if (executionRevertedError instanceof BaseError2)
      return new ExecutionRevertedError({
        cause: err,
        message: executionRevertedError.details
      });
    if (ExecutionRevertedError.nodeMessage.test(message))
      return new ExecutionRevertedError({
        cause: err,
        message: err.details
      });
    if (FeeCapTooHighError.nodeMessage.test(message))
      return new FeeCapTooHighError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (FeeCapTooLowError.nodeMessage.test(message))
      return new FeeCapTooLowError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas
      });
    if (NonceTooHighError.nodeMessage.test(message))
      return new NonceTooHighError({ cause: err, nonce: args?.nonce });
    if (NonceTooLowError.nodeMessage.test(message))
      return new NonceTooLowError({ cause: err, nonce: args?.nonce });
    if (NonceMaxValueError.nodeMessage.test(message))
      return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
    if (InsufficientFundsError.nodeMessage.test(message))
      return new InsufficientFundsError({ cause: err });
    if (IntrinsicGasTooHighError.nodeMessage.test(message))
      return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
    if (IntrinsicGasTooLowError.nodeMessage.test(message))
      return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
    if (TransactionTypeNotSupportedError.nodeMessage.test(message))
      return new TransactionTypeNotSupportedError({ cause: err });
    if (TipAboveFeeCapError.nodeMessage.test(message))
      return new TipAboveFeeCapError({
        cause: err,
        maxFeePerGas: args?.maxFeePerGas,
        maxPriorityFeePerGas: args?.maxPriorityFeePerGas
      });
    return new UnknownNodeError({
      cause: err
    });
  }
  var init_getNodeError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getNodeError.js"() {
      init_base();
      init_node();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js
  function extract(value_, { format }) {
    if (!format)
      return {};
    const value = {};
    function extract_(formatted2) {
      const keys = Object.keys(formatted2);
      for (const key of keys) {
        if (key in value_)
          value[key] = value_[key];
        if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
          extract_(formatted2[key]);
      }
    }
    const formatted = format(value_ || {});
    extract_(formatted);
    return value;
  }
  var init_extract = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/extract.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js
  function defineFormatter(type, format) {
    return ({ exclude, format: overrides }) => {
      return {
        exclude,
        format: (args) => {
          const formatted = format(args);
          if (exclude) {
            for (const key of exclude) {
              delete formatted[key];
            }
          }
          return {
            ...formatted,
            ...overrides(args)
          };
        },
        type
      };
    };
  }
  var init_formatter = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/formatter.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js
  function formatTransactionRequest(request) {
    const rpcRequest = {};
    if (typeof request.authorizationList !== "undefined")
      rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
    if (typeof request.accessList !== "undefined")
      rpcRequest.accessList = request.accessList;
    if (typeof request.blobVersionedHashes !== "undefined")
      rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
    if (typeof request.blobs !== "undefined") {
      if (typeof request.blobs[0] !== "string")
        rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
      else
        rpcRequest.blobs = request.blobs;
    }
    if (typeof request.data !== "undefined")
      rpcRequest.data = request.data;
    if (typeof request.from !== "undefined")
      rpcRequest.from = request.from;
    if (typeof request.gas !== "undefined")
      rpcRequest.gas = numberToHex(request.gas);
    if (typeof request.gasPrice !== "undefined")
      rpcRequest.gasPrice = numberToHex(request.gasPrice);
    if (typeof request.maxFeePerBlobGas !== "undefined")
      rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
    if (typeof request.maxFeePerGas !== "undefined")
      rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
    if (typeof request.maxPriorityFeePerGas !== "undefined")
      rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
    if (typeof request.nonce !== "undefined")
      rpcRequest.nonce = numberToHex(request.nonce);
    if (typeof request.to !== "undefined")
      rpcRequest.to = request.to;
    if (typeof request.type !== "undefined")
      rpcRequest.type = rpcTransactionType[request.type];
    if (typeof request.value !== "undefined")
      rpcRequest.value = numberToHex(request.value);
    return rpcRequest;
  }
  function formatAuthorizationList(authorizationList) {
    return authorizationList.map((authorization) => ({
      address: authorization.contractAddress,
      r: authorization.r,
      s: authorization.s,
      chainId: numberToHex(authorization.chainId),
      nonce: numberToHex(authorization.nonce),
      ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
      ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
    }));
  }
  var rpcTransactionType, defineTransactionRequest;
  var init_transactionRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionRequest.js"() {
      init_toHex();
      init_formatter();
      rpcTransactionType = {
        legacy: "0x0",
        eip2930: "0x1",
        eip1559: "0x2",
        eip4844: "0x3",
        eip7702: "0x4"
      };
      defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js
  function serializeStateMapping(stateMapping) {
    if (!stateMapping || stateMapping.length === 0)
      return void 0;
    return stateMapping.reduce((acc, { slot, value }) => {
      if (slot.length !== 66)
        throw new InvalidBytesLengthError({
          size: slot.length,
          targetSize: 66,
          type: "hex"
        });
      if (value.length !== 66)
        throw new InvalidBytesLengthError({
          size: value.length,
          targetSize: 66,
          type: "hex"
        });
      acc[slot] = value;
      return acc;
    }, {});
  }
  function serializeAccountStateOverride(parameters) {
    const { balance, nonce, state, stateDiff, code } = parameters;
    const rpcAccountStateOverride = {};
    if (code !== void 0)
      rpcAccountStateOverride.code = code;
    if (balance !== void 0)
      rpcAccountStateOverride.balance = numberToHex(balance);
    if (nonce !== void 0)
      rpcAccountStateOverride.nonce = numberToHex(nonce);
    if (state !== void 0)
      rpcAccountStateOverride.state = serializeStateMapping(state);
    if (stateDiff !== void 0) {
      if (rpcAccountStateOverride.state)
        throw new StateAssignmentConflictError();
      rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
    }
    return rpcAccountStateOverride;
  }
  function serializeStateOverride(parameters) {
    if (!parameters)
      return void 0;
    const rpcStateOverride = {};
    for (const { address, ...accountState } of parameters) {
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      if (rpcStateOverride[address])
        throw new AccountStateConflictError({ address });
      rpcStateOverride[address] = serializeAccountStateOverride(accountState);
    }
    return rpcStateOverride;
  }
  var init_stateOverride2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/stateOverride.js"() {
      init_address();
      init_data();
      init_stateOverride();
      init_isAddress();
      init_toHex();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js
  var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
  var init_number = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/number.js"() {
      maxInt8 = 2n ** (8n - 1n) - 1n;
      maxInt16 = 2n ** (16n - 1n) - 1n;
      maxInt24 = 2n ** (24n - 1n) - 1n;
      maxInt32 = 2n ** (32n - 1n) - 1n;
      maxInt40 = 2n ** (40n - 1n) - 1n;
      maxInt48 = 2n ** (48n - 1n) - 1n;
      maxInt56 = 2n ** (56n - 1n) - 1n;
      maxInt64 = 2n ** (64n - 1n) - 1n;
      maxInt72 = 2n ** (72n - 1n) - 1n;
      maxInt80 = 2n ** (80n - 1n) - 1n;
      maxInt88 = 2n ** (88n - 1n) - 1n;
      maxInt96 = 2n ** (96n - 1n) - 1n;
      maxInt104 = 2n ** (104n - 1n) - 1n;
      maxInt112 = 2n ** (112n - 1n) - 1n;
      maxInt120 = 2n ** (120n - 1n) - 1n;
      maxInt128 = 2n ** (128n - 1n) - 1n;
      maxInt136 = 2n ** (136n - 1n) - 1n;
      maxInt144 = 2n ** (144n - 1n) - 1n;
      maxInt152 = 2n ** (152n - 1n) - 1n;
      maxInt160 = 2n ** (160n - 1n) - 1n;
      maxInt168 = 2n ** (168n - 1n) - 1n;
      maxInt176 = 2n ** (176n - 1n) - 1n;
      maxInt184 = 2n ** (184n - 1n) - 1n;
      maxInt192 = 2n ** (192n - 1n) - 1n;
      maxInt200 = 2n ** (200n - 1n) - 1n;
      maxInt208 = 2n ** (208n - 1n) - 1n;
      maxInt216 = 2n ** (216n - 1n) - 1n;
      maxInt224 = 2n ** (224n - 1n) - 1n;
      maxInt232 = 2n ** (232n - 1n) - 1n;
      maxInt240 = 2n ** (240n - 1n) - 1n;
      maxInt248 = 2n ** (248n - 1n) - 1n;
      maxInt256 = 2n ** (256n - 1n) - 1n;
      minInt8 = -(2n ** (8n - 1n));
      minInt16 = -(2n ** (16n - 1n));
      minInt24 = -(2n ** (24n - 1n));
      minInt32 = -(2n ** (32n - 1n));
      minInt40 = -(2n ** (40n - 1n));
      minInt48 = -(2n ** (48n - 1n));
      minInt56 = -(2n ** (56n - 1n));
      minInt64 = -(2n ** (64n - 1n));
      minInt72 = -(2n ** (72n - 1n));
      minInt80 = -(2n ** (80n - 1n));
      minInt88 = -(2n ** (88n - 1n));
      minInt96 = -(2n ** (96n - 1n));
      minInt104 = -(2n ** (104n - 1n));
      minInt112 = -(2n ** (112n - 1n));
      minInt120 = -(2n ** (120n - 1n));
      minInt128 = -(2n ** (128n - 1n));
      minInt136 = -(2n ** (136n - 1n));
      minInt144 = -(2n ** (144n - 1n));
      minInt152 = -(2n ** (152n - 1n));
      minInt160 = -(2n ** (160n - 1n));
      minInt168 = -(2n ** (168n - 1n));
      minInt176 = -(2n ** (176n - 1n));
      minInt184 = -(2n ** (184n - 1n));
      minInt192 = -(2n ** (192n - 1n));
      minInt200 = -(2n ** (200n - 1n));
      minInt208 = -(2n ** (208n - 1n));
      minInt216 = -(2n ** (216n - 1n));
      minInt224 = -(2n ** (224n - 1n));
      minInt232 = -(2n ** (232n - 1n));
      minInt240 = -(2n ** (240n - 1n));
      minInt248 = -(2n ** (248n - 1n));
      minInt256 = -(2n ** (256n - 1n));
      maxUint8 = 2n ** 8n - 1n;
      maxUint16 = 2n ** 16n - 1n;
      maxUint24 = 2n ** 24n - 1n;
      maxUint32 = 2n ** 32n - 1n;
      maxUint40 = 2n ** 40n - 1n;
      maxUint48 = 2n ** 48n - 1n;
      maxUint56 = 2n ** 56n - 1n;
      maxUint64 = 2n ** 64n - 1n;
      maxUint72 = 2n ** 72n - 1n;
      maxUint80 = 2n ** 80n - 1n;
      maxUint88 = 2n ** 88n - 1n;
      maxUint96 = 2n ** 96n - 1n;
      maxUint104 = 2n ** 104n - 1n;
      maxUint112 = 2n ** 112n - 1n;
      maxUint120 = 2n ** 120n - 1n;
      maxUint128 = 2n ** 128n - 1n;
      maxUint136 = 2n ** 136n - 1n;
      maxUint144 = 2n ** 144n - 1n;
      maxUint152 = 2n ** 152n - 1n;
      maxUint160 = 2n ** 160n - 1n;
      maxUint168 = 2n ** 168n - 1n;
      maxUint176 = 2n ** 176n - 1n;
      maxUint184 = 2n ** 184n - 1n;
      maxUint192 = 2n ** 192n - 1n;
      maxUint200 = 2n ** 200n - 1n;
      maxUint208 = 2n ** 208n - 1n;
      maxUint216 = 2n ** 216n - 1n;
      maxUint224 = 2n ** 224n - 1n;
      maxUint232 = 2n ** 232n - 1n;
      maxUint240 = 2n ** 240n - 1n;
      maxUint248 = 2n ** 248n - 1n;
      maxUint256 = 2n ** 256n - 1n;
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js
  function assertRequest(args) {
    const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (account && !isAddress(account.address))
      throw new InvalidAddressError({ address: account.address });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
      throw new FeeConflictError();
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  var init_assertRequest = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertRequest.js"() {
      init_parseAccount();
      init_number();
      init_address();
      init_node();
      init_transaction();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js
  function isAddressEqual(a, b) {
    if (!isAddress(a, { strict: false }))
      throw new InvalidAddressError({ address: a });
    if (!isAddress(b, { strict: false }))
      throw new InvalidAddressError({ address: b });
    return a.toLowerCase() === b.toLowerCase();
  }
  var init_isAddressEqual = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/isAddressEqual.js"() {
      init_address();
      init_isAddress();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
  function decodeFunctionResult(parameters) {
    const { abi: abi2, args, functionName, data } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, args, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath4 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath4 });
    const values = decodeAbiParameters(abiItem.outputs, data);
    if (values && values.length > 1)
      return values;
    if (values && values.length === 1)
      return values[0];
    return void 0;
  }
  var docsPath4;
  var init_decodeFunctionResult = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js"() {
      init_abi();
      init_decodeAbiParameters();
      init_getAbiItem();
      docsPath4 = "/docs/contract/decodeFunctionResult";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js
  var multicall3Abi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, universalSignatureValidatorAbi, erc20Abi, erc20Abi_bytes32, erc721Abi, erc4626Abi;
  var init_abis = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/abis.js"() {
      multicall3Abi = [
        {
          inputs: [
            {
              components: [
                {
                  name: "target",
                  type: "address"
                },
                {
                  name: "allowFailure",
                  type: "bool"
                },
                {
                  name: "callData",
                  type: "bytes"
                }
              ],
              name: "calls",
              type: "tuple[]"
            }
          ],
          name: "aggregate3",
          outputs: [
            {
              components: [
                {
                  name: "success",
                  type: "bool"
                },
                {
                  name: "returnData",
                  type: "bytes"
                }
              ],
              name: "returnData",
              type: "tuple[]"
            }
          ],
          stateMutability: "view",
          type: "function"
        }
      ];
      universalResolverErrors = [
        {
          inputs: [],
          name: "ResolverNotFound",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverWildcardNotSupported",
          type: "error"
        },
        {
          inputs: [],
          name: "ResolverNotContract",
          type: "error"
        },
        {
          inputs: [
            {
              name: "returnData",
              type: "bytes"
            }
          ],
          name: "ResolverError",
          type: "error"
        },
        {
          inputs: [
            {
              components: [
                {
                  name: "status",
                  type: "uint16"
                },
                {
                  name: "message",
                  type: "string"
                }
              ],
              name: "errors",
              type: "tuple[]"
            }
          ],
          name: "HttpError",
          type: "error"
        }
      ];
      universalResolverResolveAbi = [
        ...universalResolverErrors,
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        },
        {
          name: "resolve",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes" },
            { name: "data", type: "bytes" },
            { name: "gateways", type: "string[]" }
          ],
          outputs: [
            { name: "", type: "bytes" },
            { name: "address", type: "address" }
          ]
        }
      ];
      universalResolverReverseAbi = [
        ...universalResolverErrors,
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [{ type: "bytes", name: "reverseName" }],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        },
        {
          name: "reverse",
          type: "function",
          stateMutability: "view",
          inputs: [
            { type: "bytes", name: "reverseName" },
            { type: "string[]", name: "gateways" }
          ],
          outputs: [
            { type: "string", name: "resolvedName" },
            { type: "address", name: "resolvedAddress" },
            { type: "address", name: "reverseResolver" },
            { type: "address", name: "resolver" }
          ]
        }
      ];
      textResolverAbi = [
        {
          name: "text",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "key", type: "string" }
          ],
          outputs: [{ name: "", type: "string" }]
        }
      ];
      addressResolverAbi = [
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [{ name: "name", type: "bytes32" }],
          outputs: [{ name: "", type: "address" }]
        },
        {
          name: "addr",
          type: "function",
          stateMutability: "view",
          inputs: [
            { name: "name", type: "bytes32" },
            { name: "coinType", type: "uint256" }
          ],
          outputs: [{ name: "", type: "bytes" }]
        }
      ];
      universalSignatureValidatorAbi = [
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          stateMutability: "nonpayable",
          type: "constructor"
        },
        {
          inputs: [
            {
              name: "_signer",
              type: "address"
            },
            {
              name: "_hash",
              type: "bytes32"
            },
            {
              name: "_signature",
              type: "bytes"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function",
          name: "isValidSig"
        }
      ];
      erc20Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc20Abi_bytes32 = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "allowance",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "decimals",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint8"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "bytes32"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transfer",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        }
      ];
      erc721Abi = [
        {
          type: "event",
          name: "Approval",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "event",
          name: "ApprovalForAll",
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "operator",
              type: "address"
            },
            {
              indexed: false,
              name: "approved",
              type: "bool"
            }
          ]
        },
        {
          type: "event",
          name: "Transfer",
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: true,
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "approve",
          stateMutability: "payable",
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "balanceOf",
          stateMutability: "view",
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "getApproved",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "isApprovedForAll",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "operator",
              type: "address"
            }
          ],
          outputs: [
            {
              type: "bool"
            }
          ]
        },
        {
          type: "function",
          name: "name",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "ownerOf",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "owner",
              type: "address"
            }
          ]
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "safeTransferFrom",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "id",
              type: "uint256"
            },
            {
              name: "data",
              type: "bytes"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "setApprovalForAll",
          stateMutability: "nonpayable",
          inputs: [
            {
              name: "operator",
              type: "address"
            },
            {
              name: "approved",
              type: "bool"
            }
          ],
          outputs: []
        },
        {
          type: "function",
          name: "symbol",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenByIndex",
          stateMutability: "view",
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "index",
              type: "uint256"
            }
          ],
          outputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "tokenURI",
          stateMutability: "view",
          inputs: [
            {
              name: "tokenId",
              type: "uint256"
            }
          ],
          outputs: [
            {
              type: "string"
            }
          ]
        },
        {
          type: "function",
          name: "totalSupply",
          stateMutability: "view",
          inputs: [],
          outputs: [
            {
              type: "uint256"
            }
          ]
        },
        {
          type: "function",
          name: "transferFrom",
          stateMutability: "payable",
          inputs: [
            {
              name: "sender",
              type: "address"
            },
            {
              name: "recipient",
              type: "address"
            },
            {
              name: "tokeId",
              type: "uint256"
            }
          ],
          outputs: []
        }
      ];
      erc4626Abi = [
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: true,
              name: "spender",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Approval",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Deposit",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "from",
              type: "address"
            },
            {
              indexed: true,
              name: "to",
              type: "address"
            },
            {
              indexed: false,
              name: "value",
              type: "uint256"
            }
          ],
          name: "Transfer",
          type: "event"
        },
        {
          anonymous: false,
          inputs: [
            {
              indexed: true,
              name: "sender",
              type: "address"
            },
            {
              indexed: true,
              name: "receiver",
              type: "address"
            },
            {
              indexed: true,
              name: "owner",
              type: "address"
            },
            {
              indexed: false,
              name: "assets",
              type: "uint256"
            },
            {
              indexed: false,
              name: "shares",
              type: "uint256"
            }
          ],
          name: "Withdraw",
          type: "event"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            },
            {
              name: "spender",
              type: "address"
            }
          ],
          name: "allowance",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "spender",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "approve",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "asset",
          outputs: [
            {
              name: "assetTokenAddress",
              type: "address"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "account",
              type: "address"
            }
          ],
          name: "balanceOf",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "convertToAssets",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "convertToShares",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "deposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxDeposit",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "caller",
              type: "address"
            }
          ],
          name: "maxMint",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxRedeem",
          outputs: [
            {
              name: "maxShares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "maxWithdraw",
          outputs: [
            {
              name: "maxAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            }
          ],
          name: "mint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewDeposit",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewMint",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          name: "previewRedeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          name: "previewWithdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "shares",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "redeem",
          outputs: [
            {
              name: "assets",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [],
          name: "totalAssets",
          outputs: [
            {
              name: "totalManagedAssets",
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [],
          name: "totalSupply",
          outputs: [
            {
              type: "uint256"
            }
          ],
          stateMutability: "view",
          type: "function"
        },
        {
          inputs: [
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transfer",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "from",
              type: "address"
            },
            {
              name: "to",
              type: "address"
            },
            {
              name: "amount",
              type: "uint256"
            }
          ],
          name: "transferFrom",
          outputs: [
            {
              type: "bool"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        },
        {
          inputs: [
            {
              name: "assets",
              type: "uint256"
            },
            {
              name: "receiver",
              type: "address"
            },
            {
              name: "owner",
              type: "address"
            }
          ],
          name: "withdraw",
          outputs: [
            {
              name: "shares",
              type: "uint256"
            }
          ],
          stateMutability: "nonpayable",
          type: "function"
        }
      ];
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js
  var aggregate3Signature;
  var init_contract2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contract.js"() {
      aggregate3Signature = "0x82ad56cb";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js
  var deploylessCallViaBytecodeBytecode, deploylessCallViaFactoryBytecode, universalSignatureValidatorByteCode;
  var init_contracts = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/contracts.js"() {
      deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
      deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
      universalSignatureValidatorByteCode = "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";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js
  var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError;
  var init_chain = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/chain.js"() {
      init_base();
      ChainDoesNotSupportContract = class extends BaseError2 {
        constructor({ blockNumber, chain, contract }) {
          super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
            metaMessages: [
              "This could be due to any of the following:",
              ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
                `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
              ] : [
                `- The chain does not have the contract "${contract.name}" configured.`
              ]
            ],
            name: "ChainDoesNotSupportContract"
          });
        }
      };
      ChainMismatchError = class extends BaseError2 {
        constructor({ chain, currentChainId }) {
          super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`, {
            metaMessages: [
              `Current Chain ID:  ${currentChainId}`,
              `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
            ],
            name: "ChainMismatchError"
          });
        }
      };
      ChainNotFoundError = class extends BaseError2 {
        constructor() {
          super([
            "No chain was provided to the request.",
            "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
          ].join("\n"), {
            name: "ChainNotFoundError"
          });
        }
      };
      ClientChainNotConfiguredError = class extends BaseError2 {
        constructor() {
          super("No chain was provided to the Client.", {
            name: "ClientChainNotConfiguredError"
          });
        }
      };
      InvalidChainIdError = class extends BaseError2 {
        constructor({ chainId }) {
          super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js
  function encodeDeployData(parameters) {
    const { abi: abi2, args, bytecode } = parameters;
    if (!args || args.length === 0)
      return bytecode;
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath5 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath5 });
    const data = encodeAbiParameters(description.inputs, args);
    return concatHex([bytecode, data]);
  }
  var docsPath5;
  var init_encodeDeployData = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeDeployData.js"() {
      init_abi();
      init_concat();
      init_encodeAbiParameters();
      docsPath5 = "/docs/contract/encodeDeployData";
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
  function getChainContractAddress({ blockNumber, chain, contract: name }) {
    const contract = chain?.contracts?.[name];
    if (!contract)
      throw new ChainDoesNotSupportContract({
        chain,
        contract: { name }
      });
    if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
      throw new ChainDoesNotSupportContract({
        blockNumber,
        chain,
        contract: {
          name,
          blockCreated: contract.blockCreated
        }
      });
    return contract.address;
  }
  var init_getChainContractAddress = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/getChainContractAddress.js"() {
      init_chain();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js
  function getCallError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new CallExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }
  var init_getCallError = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getCallError.js"() {
      init_contract();
      init_node();
      init_getNodeError();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js
  function withResolvers() {
    let resolve = () => void 0;
    let reject = () => void 0;
    const promise = new Promise((resolve_, reject_) => {
      resolve = resolve_;
      reject = reject_;
    });
    return { promise, resolve, reject };
  }
  var init_withResolvers = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withResolvers.js"() {
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
  function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait2 = 0, sort }) {
    const exec = async () => {
      const scheduler = getScheduler();
      flush();
      const args = scheduler.map(({ args: args2 }) => args2);
      if (args.length === 0)
        return;
      fn(args).then((data) => {
        if (sort && Array.isArray(data))
          data.sort(sort);
        for (let i = 0; i < scheduler.length; i++) {
          const { resolve } = scheduler[i];
          resolve?.([data[i], data]);
        }
      }).catch((err) => {
        for (let i = 0; i < scheduler.length; i++) {
          const { reject } = scheduler[i];
          reject?.(err);
        }
      });
    };
    const flush = () => schedulerCache.delete(id);
    const getBatchedArgs = () => getScheduler().map(({ args }) => args);
    const getScheduler = () => schedulerCache.get(id) || [];
    const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
    return {
      flush,
      async schedule(args) {
        const { promise, resolve, reject } = withResolvers();
        const split2 = shouldSplitBatch?.([...getBatchedArgs(), args]);
        if (split2)
          exec();
        const hasActiveScheduler = getScheduler().length > 0;
        if (hasActiveScheduler) {
          setScheduler({ args, resolve, reject });
          return promise;
        }
        setScheduler({ args, resolve, reject });
        setTimeout(exec, wait2);
        return promise;
      }
    };
  }
  var schedulerCache;
  var init_createBatchScheduler = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/createBatchScheduler.js"() {
      init_withResolvers();
      schedulerCache = /* @__PURE__ */ new Map();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js
  var OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError;
  var init_ccip = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ccip.js"() {
      init_stringify();
      init_base();
      init_utils3();
      OffchainLookupError = class extends BaseError2 {
        constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
          super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
            cause,
            metaMessages: [
              ...cause.metaMessages || [],
              cause.metaMessages?.length ? "" : [],
              "Offchain Gateway Call:",
              urls && [
                "  Gateway URL(s):",
                ...urls.map((url) => `    ${getUrl(url)}`)
              ],
              `  Sender: ${sender}`,
              `  Data: ${data}`,
              `  Callback selector: ${callbackSelector}`,
              `  Extra data: ${extraData}`
            ].flat(),
            name: "OffchainLookupError"
          });
        }
      };
      OffchainLookupResponseMalformedError = class extends BaseError2 {
        constructor({ result, url }) {
          super("Offchain gateway response is malformed. Response data must be a hex value.", {
            metaMessages: [
              `Gateway URL: ${getUrl(url)}`,
              `Response: ${stringify(result)}`
            ],
            name: "OffchainLookupResponseMalformedError"
          });
        }
      };
      OffchainLookupSenderMismatchError = class extends BaseError2 {
        constructor({ sender, to }) {
          super("Reverted sender address does not match target contract address (`to`).", {
            metaMessages: [
              `Contract address: ${to}`,
              `OffchainLookup sender address: ${sender}`
            ],
            name: "OffchainLookupSenderMismatchError"
          });
        }
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js
  var ccip_exports = {};
  __export(ccip_exports, {
    ccipRequest: () => ccipRequest,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature
  });
  async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
    const { args } = decodeErrorResult({
      data,
      abi: [offchainLookupAbiItem]
    });
    const [sender, urls, callData, callbackSelector, extraData] = args;
    const { ccipRead } = client;
    const ccipRequest_ = ccipRead && typeof ccipRead?.request === "function" ? ccipRead.request : ccipRequest;
    try {
      if (!isAddressEqual(to, sender))
        throw new OffchainLookupSenderMismatchError({ sender, to });
      const result = await ccipRequest_({ data: callData, sender, urls });
      const { data: data_ } = await call(client, {
        blockNumber,
        blockTag,
        data: concat([
          callbackSelector,
          encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
        ]),
        to
      });
      return data_;
    } catch (err) {
      throw new OffchainLookupError({
        callbackSelector,
        cause: err,
        data,
        extraData,
        sender,
        urls
      });
    }
  }
  async function ccipRequest({ data, sender, urls }) {
    let error = new Error("An unknown error occurred.");
    for (let i = 0; i < urls.length; i++) {
      const url = urls[i];
      const method = url.includes("{data}") ? "GET" : "POST";
      const body = method === "POST" ? { data, sender } : void 0;
      const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
      try {
        const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
          body: JSON.stringify(body),
          headers,
          method
        });
        let result;
        if (response.headers.get("Content-Type")?.startsWith("application/json")) {
          result = (await response.json()).data;
        } else {
          result = await response.text();
        }
        if (!response.ok) {
          error = new HttpRequestError({
            body,
            details: result?.error ? stringify(result.error) : response.statusText,
            headers: response.headers,
            status: response.status,
            url
          });
          continue;
        }
        if (!isHex(result)) {
          error = new OffchainLookupResponseMalformedError({
            result,
            url
          });
          continue;
        }
        return result;
      } catch (err) {
        error = new HttpRequestError({
          body,
          details: err.message,
          url
        });
      }
    }
    throw error;
  }
  var offchainLookupSignature, offchainLookupAbiItem;
  var init_ccip2 = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ccip.js"() {
      init_call();
      init_ccip();
      init_request();
      init_decodeErrorResult();
      init_encodeAbiParameters();
      init_isAddressEqual();
      init_concat();
      init_isHex();
      init_stringify();
      offchainLookupSignature = "0x556f1830";
      offchainLookupAbiItem = {
        name: "OffchainLookup",
        type: "error",
        inputs: [
          {
            name: "sender",
            type: "address"
          },
          {
            name: "urls",
            type: "string[]"
          },
          {
            name: "callData",
            type: "bytes"
          },
          {
            name: "callbackFunction",
            type: "bytes4"
          },
          {
            name: "extraData",
            type: "bytes"
          }
        ]
      };
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js
  async function call(client, args) {
    const { account: account_ = client.account, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    if (code && (factory || factoryData))
      throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
    if (code && to)
      throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
    const deploylessCallViaBytecode = code && data_;
    const deploylessCallViaFactory = factory && factoryData && to && data_;
    const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
    const data = (() => {
      if (deploylessCallViaBytecode)
        return toDeploylessCallViaBytecodeData({
          code,
          data: data_
        });
      if (deploylessCallViaFactory)
        return toDeploylessCallViaFactoryData({
          data: data_,
          factory,
          factoryData,
          to
        });
      return data_;
    })();
    try {
      assertRequest(args);
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        blobs,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to: deploylessCall ? void 0 : to,
        value
      });
      if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
        try {
          return await scheduleMulticall(client, {
            ...request,
            blockNumber,
            blockTag
          });
        } catch (err) {
          if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
            throw err;
        }
      }
      const response = await client.request({
        method: "eth_call",
        params: rpcStateOverride ? [
          request,
          block,
          rpcStateOverride
        ] : [request, block]
      });
      if (response === "0x")
        return { data: void 0 };
      return { data: response };
    } catch (err) {
      const data2 = getRevertErrorData(err);
      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
      if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
        return { data: await offchainLookup2(client, { data: data2, to }) };
      if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
        throw new CounterfactualDeploymentFailedError({ factory });
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }
  function shouldPerformMulticall({ request }) {
    const { data, to, ...request_ } = request;
    if (!data)
      return false;
    if (data.startsWith(aggregate3Signature))
      return false;
    if (!to)
      return false;
    if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
      return false;
    return true;
  }
  async function scheduleMulticall(client, args) {
    const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
    const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new ClientChainNotConfiguredError();
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const block = blockNumberHex || blockTag;
    const { schedule } = createBatchScheduler({
      id: `${client.uid}.${block}`,
      wait: wait2,
      shouldSplitBatch(args2) {
        const size3 = args2.reduce((size4, { data: data2 }) => size4 + (data2.length - 2), 0);
        return size3 > batchSize * 2;
      },
      fn: async (requests) => {
        const calls = requests.map((request) => ({
          allowFailure: true,
          callData: request.data,
          target: request.to
        }));
        const calldata = encodeFunctionData({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3"
        });
        const data2 = await client.request({
          method: "eth_call",
          params: [
            {
              data: calldata,
              to: multicallAddress
            },
            block
          ]
        });
        return decodeFunctionResult({
          abi: multicall3Abi,
          args: [calls],
          functionName: "aggregate3",
          data: data2 || "0x"
        });
      }
    });
    const [{ returnData, success }] = await schedule({ data, to });
    if (!success)
      throw new RawContractError({ data: returnData });
    if (returnData === "0x")
      return { data: void 0 };
    return { data: returnData };
  }
  function toDeploylessCallViaBytecodeData(parameters) {
    const { code, data } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(bytes, bytes)"]),
      bytecode: deploylessCallViaBytecodeBytecode,
      args: [code, data]
    });
  }
  function toDeploylessCallViaFactoryData(parameters) {
    const { data, factory, factoryData, to } = parameters;
    return encodeDeployData({
      abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
      bytecode: deploylessCallViaFactoryBytecode,
      args: [to, data, factory, factoryData]
    });
  }
  function getRevertErrorData(err) {
    if (!(err instanceof BaseError2))
      return void 0;
    const error = err.walk();
    return typeof error?.data === "object" ? error.data?.data : error.data;
  }
  var init_call = __esm({
    "node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/call.js"() {
      init_exports();
      init_parseAccount();
      init_abis();
      init_contract2();
      init_contracts();
      init_base();
      init_chain();
      init_contract();
      init_decodeFunctionResult();
      init_encodeDeployData();
      init_encodeFunctionData();
      init_getChainContractAddress();
      init_toHex();
      init_getCallError();
      init_extract();
      init_transactionRequest();
      init_createBatchScheduler();
      init_stateOverride2();
      init_assertRequest();
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js
  function getNativeWebSocket() {
    if (typeof WebSocket !== "undefined")
      return WebSocket;
    if (typeof global.WebSocket !== "undefined")
      return global.WebSocket;
    if (typeof window.WebSocket !== "undefined")
      return window.WebSocket;
    if (typeof self.WebSocket !== "undefined")
      return self.WebSocket;
    throw new Error("`WebSocket` is not supported in this environment");
  }
  var init_utils5 = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/utils.js"() {
    }
  });

  // node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js
  var native_exports = {};
  __export(native_exports, {
    WebSocket: () => WebSocket2
  });
  var WebSocket2;
  var init_native = __esm({
    "node_modules/.deno/isows@1.0.6/node_modules/isows/_esm/native.js"() {
      init_utils5();
      WebSocket2 = getNativeWebSocket();
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    AbiConstructorNotFoundError: () => AbiConstructorNotFoundError,
    AbiConstructorParamsNotFoundError: () => AbiConstructorParamsNotFoundError,
    AbiDecodingDataSizeInvalidError: () => AbiDecodingDataSizeInvalidError,
    AbiDecodingDataSizeTooSmallError: () => AbiDecodingDataSizeTooSmallError,
    AbiDecodingZeroDataError: () => AbiDecodingZeroDataError,
    AbiEncodingArrayLengthMismatchError: () => AbiEncodingArrayLengthMismatchError,
    AbiEncodingBytesSizeMismatchError: () => AbiEncodingBytesSizeMismatchError,
    AbiEncodingLengthMismatchError: () => AbiEncodingLengthMismatchError,
    AbiErrorInputsNotFoundError: () => AbiErrorInputsNotFoundError,
    AbiErrorNotFoundError: () => AbiErrorNotFoundError,
    AbiErrorSignatureNotFoundError: () => AbiErrorSignatureNotFoundError,
    AbiEventNotFoundError: () => AbiEventNotFoundError,
    AbiEventSignatureEmptyTopicsError: () => AbiEventSignatureEmptyTopicsError,
    AbiEventSignatureNotFoundError: () => AbiEventSignatureNotFoundError,
    AbiFunctionNotFoundError: () => AbiFunctionNotFoundError,
    AbiFunctionOutputsNotFoundError: () => AbiFunctionOutputsNotFoundError,
    AbiFunctionSignatureNotFoundError: () => AbiFunctionSignatureNotFoundError,
    AccountStateConflictError: () => AccountStateConflictError,
    BaseError: () => BaseError2,
    BaseFeeScalarError: () => BaseFeeScalarError,
    BlockNotFoundError: () => BlockNotFoundError,
    BytesSizeMismatchError: () => BytesSizeMismatchError,
    CallExecutionError: () => CallExecutionError,
    ChainDisconnectedError: () => ChainDisconnectedError,
    ChainDoesNotSupportContract: () => ChainDoesNotSupportContract,
    ChainMismatchError: () => ChainMismatchError,
    ChainNotFoundError: () => ChainNotFoundError,
    CircularReferenceError: () => CircularReferenceError,
    ClientChainNotConfiguredError: () => ClientChainNotConfiguredError,
    ContractFunctionExecutionError: () => ContractFunctionExecutionError,
    ContractFunctionRevertedError: () => ContractFunctionRevertedError,
    ContractFunctionZeroDataError: () => ContractFunctionZeroDataError,
    CounterfactualDeploymentFailedError: () => CounterfactualDeploymentFailedError,
    DecodeLogDataMismatch: () => DecodeLogDataMismatch,
    DecodeLogTopicsMismatch: () => DecodeLogTopicsMismatch,
    EIP1193ProviderRpcError: () => ProviderRpcError2,
    Eip1559FeesNotSupportedError: () => Eip1559FeesNotSupportedError,
    EnsAvatarInvalidNftUriError: () => EnsAvatarInvalidNftUriError,
    EnsAvatarUnsupportedNamespaceError: () => EnsAvatarUnsupportedNamespaceError,
    EnsAvatarUriResolutionError: () => EnsAvatarUriResolutionError,
    EstimateGasExecutionError: () => EstimateGasExecutionError,
    ExecutionRevertedError: () => ExecutionRevertedError,
    FeeCapTooHighError: () => FeeCapTooHighError,
    FeeCapTooLowError: () => FeeCapTooLowError,
    FeeConflictError: () => FeeConflictError,
    FilterTypeNotSupportedError: () => FilterTypeNotSupportedError,
    HttpRequestError: () => HttpRequestError,
    InsufficientFundsError: () => InsufficientFundsError,
    IntegerOutOfRangeError: () => IntegerOutOfRangeError,
    InternalRpcError: () => InternalRpcError,
    IntrinsicGasTooHighError: () => IntrinsicGasTooHighError,
    IntrinsicGasTooLowError: () => IntrinsicGasTooLowError,
    InvalidAbiDecodingTypeError: () => InvalidAbiDecodingTypeError,
    InvalidAbiEncodingTypeError: () => InvalidAbiEncodingTypeError,
    InvalidAbiItemError: () => InvalidAbiItemError,
    InvalidAbiParameterError: () => InvalidAbiParameterError,
    InvalidAbiParametersError: () => InvalidAbiParametersError,
    InvalidAbiTypeParameterError: () => InvalidAbiTypeParameterError,
    InvalidAddressError: () => InvalidAddressError,
    InvalidArrayError: () => InvalidArrayError,
    InvalidBytesBooleanError: () => InvalidBytesBooleanError,
    InvalidChainIdError: () => InvalidChainIdError,
    InvalidDecimalNumberError: () => InvalidDecimalNumberError,
    InvalidDefinitionTypeError: () => InvalidDefinitionTypeError,
    InvalidFunctionModifierError: () => InvalidFunctionModifierError,
    InvalidHexBooleanError: () => InvalidHexBooleanError,
    InvalidHexValueError: () => InvalidHexValueError,
    InvalidInputRpcError: () => InvalidInputRpcError,
    InvalidLegacyVError: () => InvalidLegacyVError,
    InvalidModifierError: () => InvalidModifierError,
    InvalidParameterError: () => InvalidParameterError,
    InvalidParamsRpcError: () => InvalidParamsRpcError,
    InvalidParenthesisError: () => InvalidParenthesisError,
    InvalidPrimaryTypeError: () => InvalidPrimaryTypeError,
    InvalidRequestRpcError: () => InvalidRequestRpcError,
    InvalidSerializableTransactionError: () => InvalidSerializableTransactionError,
    InvalidSerializedTransactionError: () => InvalidSerializedTransactionError,
    InvalidSerializedTransactionTypeError: () => InvalidSerializedTransactionTypeError,
    InvalidSignatureError: () => InvalidSignatureError,
    InvalidStorageKeySizeError: () => InvalidStorageKeySizeError,
    InvalidStructSignatureError: () => InvalidStructSignatureError,
    InvalidStructTypeError: () => InvalidStructTypeError,
    JsonRpcVersionUnsupportedError: () => JsonRpcVersionUnsupportedError,
    LimitExceededRpcError: () => LimitExceededRpcError,
    MaxFeePerGasTooLowError: () => MaxFeePerGasTooLowError,
    MethodNotFoundRpcError: () => MethodNotFoundRpcError,
    MethodNotSupportedRpcError: () => MethodNotSupportedRpcError,
    NonceMaxValueError: () => NonceMaxValueError,
    NonceTooHighError: () => NonceTooHighError,
    NonceTooLowError: () => NonceTooLowError,
    ParseRpcError: () => ParseRpcError,
    ProviderDisconnectedError: () => ProviderDisconnectedError,
    ProviderRpcError: () => ProviderRpcError,
    RawContractError: () => RawContractError,
    ResourceNotFoundRpcError: () => ResourceNotFoundRpcError,
    ResourceUnavailableRpcError: () => ResourceUnavailableRpcError,
    RpcError: () => RpcError,
    RpcRequestError: () => RpcRequestError,
    SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
    SizeOverflowError: () => SizeOverflowError,
    SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
    SocketClosedError: () => SocketClosedError,
    SolidityProtectedKeywordError: () => SolidityProtectedKeywordError,
    StateAssignmentConflictError: () => StateAssignmentConflictError,
    SwitchChainError: () => SwitchChainError,
    TimeoutError: () => TimeoutError,
    TipAboveFeeCapError: () => TipAboveFeeCapError,
    TransactionExecutionError: () => TransactionExecutionError,
    TransactionNotFoundError: () => TransactionNotFoundError,
    TransactionReceiptNotFoundError: () => TransactionReceiptNotFoundError,
    TransactionRejectedRpcError: () => TransactionRejectedRpcError,
    TransactionTypeNotSupportedError: () => TransactionTypeNotSupportedError,
    UnauthorizedProviderError: () => UnauthorizedProviderError,
    UnknownNodeError: () => UnknownNodeError,
    UnknownRpcError: () => UnknownRpcError,
    UnknownSignatureError: () => UnknownSignatureError,
    UnknownTypeError: () => UnknownTypeError,
    UnsupportedPackedAbiType: () => UnsupportedPackedAbiType,
    UnsupportedProviderMethodError: () => UnsupportedProviderMethodError,
    UrlRequiredError: () => UrlRequiredError,
    UserRejectedRequestError: () => UserRejectedRequestError,
    WaitForTransactionReceiptTimeoutError: () => WaitForTransactionReceiptTimeoutError,
    WebSocketRequestError: () => WebSocketRequestError,
    assertCurrentChain: () => assertCurrentChain,
    assertRequest: () => assertRequest,
    assertTransactionEIP1559: () => assertTransactionEIP1559,
    assertTransactionEIP2930: () => assertTransactionEIP2930,
    assertTransactionLegacy: () => assertTransactionLegacy,
    blobsToCommitments: () => blobsToCommitments,
    blobsToProofs: () => blobsToProofs,
    boolToBytes: () => boolToBytes,
    boolToHex: () => boolToHex,
    bytesToBigInt: () => bytesToBigInt,
    bytesToBool: () => bytesToBool,
    bytesToHex: () => bytesToHex,
    bytesToNumber: () => bytesToNumber,
    bytesToRlp: () => bytesToRlp,
    bytesToString: () => bytesToString,
    ccipFetch: () => ccipRequest,
    ccipRequest: () => ccipRequest,
    checksumAddress: () => checksumAddress,
    commitmentToVersionedHash: () => commitmentToVersionedHash,
    commitmentsToVersionedHashes: () => commitmentsToVersionedHashes,
    compactSignatureToHex: () => serializeCompactSignature,
    compactSignatureToSignature: () => compactSignatureToSignature,
    concat: () => concat,
    concatBytes: () => concatBytes2,
    concatHex: () => concatHex,
    createClient: () => createClient,
    createNonceManager: () => createNonceManager,
    createPublicClient: () => createPublicClient,
    createTestClient: () => createTestClient,
    createTransport: () => createTransport,
    createWalletClient: () => createWalletClient,
    custom: () => custom,
    decodeAbiParameters: () => decodeAbiParameters,
    decodeDeployData: () => decodeDeployData,
    decodeErrorResult: () => decodeErrorResult,
    decodeEventLog: () => decodeEventLog,
    decodeFunctionData: () => decodeFunctionData,
    decodeFunctionResult: () => decodeFunctionResult,
    defineBlock: () => defineBlock,
    defineChain: () => defineChain,
    defineKzg: () => defineKzg,
    defineTransaction: () => defineTransaction,
    defineTransactionReceipt: () => defineTransactionReceipt,
    defineTransactionRequest: () => defineTransactionRequest,
    deploylessCallViaBytecodeBytecode: () => deploylessCallViaBytecodeBytecode,
    deploylessCallViaFactoryBytecode: () => deploylessCallViaFactoryBytecode,
    domainSeparator: () => domainSeparator,
    encodeAbiParameters: () => encodeAbiParameters,
    encodeDeployData: () => encodeDeployData,
    encodeErrorResult: () => encodeErrorResult,
    encodeEventTopics: () => encodeEventTopics,
    encodeFunctionData: () => encodeFunctionData,
    encodeFunctionResult: () => encodeFunctionResult,
    encodePacked: () => encodePacked,
    erc20Abi: () => erc20Abi,
    erc20Abi_bytes32: () => erc20Abi_bytes32,
    erc4626Abi: () => erc4626Abi,
    erc721Abi: () => erc721Abi,
    etherUnits: () => etherUnits,
    extractChain: () => extractChain,
    fallback: () => fallback,
    formatBlock: () => formatBlock,
    formatEther: () => formatEther,
    formatGwei: () => formatGwei,
    formatLog: () => formatLog,
    formatTransaction: () => formatTransaction,
    formatTransactionReceipt: () => formatTransactionReceipt,
    formatTransactionRequest: () => formatTransactionRequest,
    formatUnits: () => formatUnits,
    fromBlobs: () => fromBlobs,
    fromBytes: () => fromBytes,
    fromHex: () => fromHex,
    fromRlp: () => fromRlp,
    getAbiItem: () => getAbiItem,
    getAddress: () => getAddress,
    getChainContractAddress: () => getChainContractAddress,
    getContract: () => getContract,
    getContractAddress: () => getContractAddress2,
    getContractError: () => getContractError,
    getCreate2Address: () => getCreate2Address,
    getCreateAddress: () => getCreateAddress,
    getEventSelector: () => toEventSelector,
    getEventSignature: () => toSignature,
    getFunctionSelector: () => toFunctionSelector,
    getFunctionSignature: () => toSignature,
    getSerializedTransactionType: () => getSerializedTransactionType,
    getTransactionType: () => getTransactionType,
    getTypesForEIP712Domain: () => getTypesForEIP712Domain,
    gweiUnits: () => gweiUnits,
    hashDomain: () => hashDomain,
    hashMessage: () => hashMessage,
    hashTypedData: () => hashTypedData,
    hexToBigInt: () => hexToBigInt,
    hexToBool: () => hexToBool,
    hexToBytes: () => hexToBytes,
    hexToCompactSignature: () => parseCompactSignature,
    hexToNumber: () => hexToNumber,
    hexToRlp: () => hexToRlp,
    hexToSignature: () => parseSignature2,
    hexToString: () => hexToString,
    http: () => http,
    isAddress: () => isAddress,
    isAddressEqual: () => isAddressEqual,
    isBytes: () => isBytes3,
    isErc6492Signature: () => isErc6492Signature,
    isHash: () => isHash,
    isHex: () => isHex,
    keccak256: () => keccak256,
    labelhash: () => labelhash,
    maxInt104: () => maxInt104,
    maxInt112: () => maxInt112,
    maxInt120: () => maxInt120,
    maxInt128: () => maxInt128,
    maxInt136: () => maxInt136,
    maxInt144: () => maxInt144,
    maxInt152: () => maxInt152,
    maxInt16: () => maxInt16,
    maxInt160: () => maxInt160,
    maxInt168: () => maxInt168,
    maxInt176: () => maxInt176,
    maxInt184: () => maxInt184,
    maxInt192: () => maxInt192,
    maxInt200: () => maxInt200,
    maxInt208: () => maxInt208,
    maxInt216: () => maxInt216,
    maxInt224: () => maxInt224,
    maxInt232: () => maxInt232,
    maxInt24: () => maxInt24,
    maxInt240: () => maxInt240,
    maxInt248: () => maxInt248,
    maxInt256: () => maxInt256,
    maxInt32: () => maxInt32,
    maxInt40: () => maxInt40,
    maxInt48: () => maxInt48,
    maxInt56: () => maxInt56,
    maxInt64: () => maxInt64,
    maxInt72: () => maxInt72,
    maxInt8: () => maxInt8,
    maxInt80: () => maxInt80,
    maxInt88: () => maxInt88,
    maxInt96: () => maxInt96,
    maxUint104: () => maxUint104,
    maxUint112: () => maxUint112,
    maxUint120: () => maxUint120,
    maxUint128: () => maxUint128,
    maxUint136: () => maxUint136,
    maxUint144: () => maxUint144,
    maxUint152: () => maxUint152,
    maxUint16: () => maxUint16,
    maxUint160: () => maxUint160,
    maxUint168: () => maxUint168,
    maxUint176: () => maxUint176,
    maxUint184: () => maxUint184,
    maxUint192: () => maxUint192,
    maxUint200: () => maxUint200,
    maxUint208: () => maxUint208,
    maxUint216: () => maxUint216,
    maxUint224: () => maxUint224,
    maxUint232: () => maxUint232,
    maxUint24: () => maxUint24,
    maxUint240: () => maxUint240,
    maxUint248: () => maxUint248,
    maxUint256: () => maxUint256,
    maxUint32: () => maxUint32,
    maxUint40: () => maxUint40,
    maxUint48: () => maxUint48,
    maxUint56: () => maxUint56,
    maxUint64: () => maxUint64,
    maxUint72: () => maxUint72,
    maxUint8: () => maxUint8,
    maxUint80: () => maxUint80,
    maxUint88: () => maxUint88,
    maxUint96: () => maxUint96,
    minInt104: () => minInt104,
    minInt112: () => minInt112,
    minInt120: () => minInt120,
    minInt128: () => minInt128,
    minInt136: () => minInt136,
    minInt144: () => minInt144,
    minInt152: () => minInt152,
    minInt16: () => minInt16,
    minInt160: () => minInt160,
    minInt168: () => minInt168,
    minInt176: () => minInt176,
    minInt184: () => minInt184,
    minInt192: () => minInt192,
    minInt200: () => minInt200,
    minInt208: () => minInt208,
    minInt216: () => minInt216,
    minInt224: () => minInt224,
    minInt232: () => minInt232,
    minInt24: () => minInt24,
    minInt240: () => minInt240,
    minInt248: () => minInt248,
    minInt256: () => minInt256,
    minInt32: () => minInt32,
    minInt40: () => minInt40,
    minInt48: () => minInt48,
    minInt56: () => minInt56,
    minInt64: () => minInt64,
    minInt72: () => minInt72,
    minInt8: () => minInt8,
    minInt80: () => minInt80,
    minInt88: () => minInt88,
    minInt96: () => minInt96,
    multicall3Abi: () => multicall3Abi,
    namehash: () => namehash,
    nonceManager: () => nonceManager,
    numberToBytes: () => numberToBytes,
    numberToHex: () => numberToHex,
    offchainLookup: () => offchainLookup,
    offchainLookupAbiItem: () => offchainLookupAbiItem,
    offchainLookupSignature: () => offchainLookupSignature,
    pad: () => pad,
    padBytes: () => padBytes,
    padHex: () => padHex,
    parseAbi: () => parseAbi,
    parseAbiItem: () => parseAbiItem,
    parseAbiParameter: () => parseAbiParameter2,
    parseAbiParameters: () => parseAbiParameters,
    parseCompactSignature: () => parseCompactSignature,
    parseErc6492Signature: () => parseErc6492Signature,
    parseEther: () => parseEther,
    parseEventLogs: () => parseEventLogs,
    parseGwei: () => parseGwei,
    parseSignature: () => parseSignature2,
    parseTransaction: () => parseTransaction,
    parseUnits: () => parseUnits,
    prepareEncodeFunctionData: () => prepareEncodeFunctionData,
    presignMessagePrefix: () => presignMessagePrefix,
    publicActions: () => publicActions,
    recoverAddress: () => recoverAddress,
    recoverMessageAddress: () => recoverMessageAddress,
    recoverPublicKey: () => recoverPublicKey,
    recoverTransactionAddress: () => recoverTransactionAddress,
    recoverTypedDataAddress: () => recoverTypedDataAddress,
    ripemd160: () => ripemd1602,
    rpcSchema: () => rpcSchema,
    rpcTransactionType: () => rpcTransactionType,
    serializeAccessList: () => serializeAccessList,
    serializeCompactSignature: () => serializeCompactSignature,
    serializeErc6492Signature: () => serializeErc6492Signature,
    serializeSignature: () => serializeSignature,
    serializeTransaction: () => serializeTransaction,
    serializeTypedData: () => serializeTypedData,
    setErrorConfig: () => setErrorConfig,
    setupKzg: () => setupKzg,
    sha256: () => sha2562,
    sidecarsToVersionedHashes: () => sidecarsToVersionedHashes,
    signatureToCompactSignature: () => signatureToCompactSignature,
    signatureToHex: () => serializeSignature,
    size: () => size,
    slice: () => slice,
    sliceBytes: () => sliceBytes,
    sliceHex: () => sliceHex,
    stringToBytes: () => stringToBytes,
    stringToHex: () => stringToHex,
    stringify: () => stringify,
    testActions: () => testActions,
    toBlobSidecars: () => toBlobSidecars,
    toBlobs: () => toBlobs,
    toBytes: () => toBytes,
    toEventHash: () => toSignatureHash,
    toEventSelector: () => toEventSelector,
    toEventSignature: () => toSignature,
    toFunctionHash: () => toSignatureHash,
    toFunctionSelector: () => toFunctionSelector,
    toFunctionSignature: () => toSignature,
    toHex: () => toHex,
    toPrefixedMessage: () => toPrefixedMessage,
    toRlp: () => toRlp,
    transactionType: () => transactionType,
    trim: () => trim,
    universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
    universalSignatureValidatorByteCode: () => universalSignatureValidatorByteCode,
    validateTypedData: () => validateTypedData,
    verifyHash: () => verifyHash,
    verifyMessage: () => verifyMessage,
    verifyTypedData: () => verifyTypedData,
    walletActions: () => walletActions,
    webSocket: () => webSocket,
    weiUnits: () => weiUnits,
    withRetry: () => withRetry,
    withTimeout: () => withTimeout,
    zeroAddress: () => zeroAddress,
    zeroHash: () => zeroHash
  });
  init_exports();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/getAction.js
  function getAction(client, actionFn, name) {
    const action_implicit = client[actionFn.name];
    if (typeof action_implicit === "function")
      return action_implicit;
    const action_explicit = client[name];
    if (typeof action_explicit === "function")
      return action_explicit;
    return (params) => actionFn(client, params);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_abi();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/log.js
  init_base();
  var FilterTypeNotSupportedError = class extends BaseError2 {
    constructor(type) {
      super(`Filter type "${type}" is not supported.`, {
        name: "FilterTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
  init_toBytes();
  init_keccak256();
  init_toEventSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath = "/docs/contract/encodeEventTopics";
  function encodeEventTopics(parameters) {
    const { abi: abi2, eventName, args } = parameters;
    let abiItem = abi2[0];
    if (eventName) {
      const item = getAbiItem({ abi: abi2, name: eventName });
      if (!item)
        throw new AbiEventNotFoundError(eventName, { docsPath });
      abiItem = item;
    }
    if (abiItem.type !== "event")
      throw new AbiEventNotFoundError(void 0, { docsPath });
    const definition = formatAbiItem2(abiItem);
    const signature = toEventSelector(definition);
    let topics = [];
    if (args && "inputs" in abiItem) {
      const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
      const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
      if (args_.length > 0) {
        topics = indexedInputs?.map((param, i) => {
          if (Array.isArray(args_[i]))
            return args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }));
          return args_[i] ? encodeArg({ param, value: args_[i] }) : null;
        }) ?? [];
      }
    }
    return [signature, ...topics];
  }
  function encodeArg({ param, value }) {
    if (param.type === "string" || param.type === "bytes")
      return keccak256(toBytes(value));
    if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      throw new FilterTypeNotSupportedError(param.type);
    return encodeAbiParameters([param], [value]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
  function createFilterRequestScope(client, { method }) {
    const requestMap = {};
    if (client.transport.type === "fallback")
      client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
        if (status === "success" && method === method_)
          requestMap[id] = transport.request;
      });
    return (id) => requestMap[id] || client.request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createContractEventFilter.js
  async function createContractEventFilter(client, parameters) {
    const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    const topics = eventName ? encodeEventTopics({
      abi: abi2,
      args,
      eventName
    }) : void 0;
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          topics
        }
      ]
    });
    return {
      abi: abi2,
      args,
      eventName,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  init_parseAccount();
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getContractError.js
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  var EXECUTION_REVERTED_ERROR_CODE = 3;
  function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
    const { code, data, message, shortMessage } = err instanceof RawContractError ? err : err instanceof BaseError2 ? err.walk((err2) => "data" in err2) || err.walk() : {};
    const cause = (() => {
      if (err instanceof AbiDecodingZeroDataError)
        return new ContractFunctionZeroDataError({ functionName });
      if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || message || shortMessage)) {
        return new ContractFunctionRevertedError({
          abi: abi2,
          data: typeof data === "object" ? data.data : data,
          functionName,
          message: shortMessage ?? message
        });
      }
      return err;
    })();
    return new ContractFunctionExecutionError(cause, {
      abi: abi2,
      args,
      contractAddress: address,
      docsPath: docsPath9,
      functionName,
      sender
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
  init_getAddress();
  init_keccak256();
  function publicKeyToAddress(publicKey) {
    const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
    return checksumAddress(`0x${address}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
  init_isHex();
  init_fromHex();
  init_toHex();
  async function recoverPublicKey({ hash: hash3, signature }) {
    const hashHex = isHex(hash3) ? hash3 : toHex(hash3);
    const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
    const signature_ = (() => {
      if (typeof signature === "object" && "r" in signature && "s" in signature) {
        const { r, s, v, yParity } = signature;
        const yParityOrV2 = Number(yParity ?? v);
        const recoveryBit2 = toRecoveryBit(yParityOrV2);
        return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
      }
      const signatureHex = isHex(signature) ? signature : toHex(signature);
      const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
      const recoveryBit = toRecoveryBit(yParityOrV);
      return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
    })();
    const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
    return `0x${publicKey}`;
  }
  function toRecoveryBit(yParityOrV) {
    if (yParityOrV === 0 || yParityOrV === 1)
      return yParityOrV;
    if (yParityOrV === 27)
      return 0;
    if (yParityOrV === 28)
      return 1;
    throw new Error("Invalid yParityOrV value");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverAddress.js
  async function recoverAddress({ hash: hash3, signature }) {
    return publicKeyToAddress(await recoverPublicKey({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_concat();
  init_toBytes();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/toRlp.js
  init_base();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function toRlp(bytes2, to = "hex") {
    const encodable = getEncodable(bytes2);
    const cursor = createCursor(new Uint8Array(encodable.length));
    encodable.encode(cursor);
    if (to === "hex")
      return bytesToHex(cursor.bytes);
    return cursor.bytes;
  }
  function bytesToRlp(bytes2, to = "bytes") {
    return toRlp(bytes2, to);
  }
  function hexToRlp(hex, to = "hex") {
    return toRlp(hex, to);
  }
  function getEncodable(bytes2) {
    if (Array.isArray(bytes2))
      return getEncodableList(bytes2.map((x) => getEncodable(x)));
    return getEncodableBytes(bytes2);
  }
  function getEncodableList(list) {
    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
    const sizeOfBodyLength = getSizeOfLength(bodyLength);
    const length = (() => {
      if (bodyLength <= 55)
        return 1 + bodyLength;
      return 1 + sizeOfBodyLength + bodyLength;
    })();
    return {
      length,
      encode(cursor) {
        if (bodyLength <= 55) {
          cursor.pushByte(192 + bodyLength);
        } else {
          cursor.pushByte(192 + 55 + sizeOfBodyLength);
          if (sizeOfBodyLength === 1)
            cursor.pushUint8(bodyLength);
          else if (sizeOfBodyLength === 2)
            cursor.pushUint16(bodyLength);
          else if (sizeOfBodyLength === 3)
            cursor.pushUint24(bodyLength);
          else
            cursor.pushUint32(bodyLength);
        }
        for (const { encode: encode2 } of list) {
          encode2(cursor);
        }
      }
    };
  }
  function getEncodableBytes(bytesOrHex) {
    const bytes2 = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
    const sizeOfBytesLength = getSizeOfLength(bytes2.length);
    const length = (() => {
      if (bytes2.length === 1 && bytes2[0] < 128)
        return 1;
      if (bytes2.length <= 55)
        return 1 + bytes2.length;
      return 1 + sizeOfBytesLength + bytes2.length;
    })();
    return {
      length,
      encode(cursor) {
        if (bytes2.length === 1 && bytes2[0] < 128) {
          cursor.pushBytes(bytes2);
        } else if (bytes2.length <= 55) {
          cursor.pushByte(128 + bytes2.length);
          cursor.pushBytes(bytes2);
        } else {
          cursor.pushByte(128 + 55 + sizeOfBytesLength);
          if (sizeOfBytesLength === 1)
            cursor.pushUint8(bytes2.length);
          else if (sizeOfBytesLength === 2)
            cursor.pushUint16(bytes2.length);
          else if (sizeOfBytesLength === 3)
            cursor.pushUint24(bytes2.length);
          else
            cursor.pushUint32(bytes2.length);
          cursor.pushBytes(bytes2);
        }
      }
    };
  }
  function getSizeOfLength(length) {
    if (length < 2 ** 8)
      return 1;
    if (length < 2 ** 16)
      return 2;
    if (length < 2 ** 24)
      return 3;
    if (length < 2 ** 32)
      return 4;
    throw new BaseError2("Length is too large.");
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/hashAuthorization.js
  init_keccak256();
  function hashAuthorization(parameters) {
    const { chainId, contractAddress, nonce, to } = parameters;
    const hash3 = keccak256(concatHex([
      "0x05",
      toRlp([
        chainId ? numberToHex(chainId) : "0x",
        contractAddress,
        nonce ? numberToHex(nonce) : "0x"
      ])
    ]));
    if (to === "bytes")
      return hexToBytes(hash3);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/recoverAuthorizationAddress.js
  async function recoverAuthorizationAddress(parameters) {
    const { authorization, signature } = parameters;
    return recoverAddress({
      hash: hashAuthorization(authorization),
      signature: signature ?? authorization
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/estimateGas.js
  init_formatEther();
  init_formatGwei();
  init_base();
  init_transaction();
  var EstimateGasExecutionError = class extends BaseError2 {
    constructor(cause, { account, docsPath: docsPath9, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
      const prettyArgs = prettyPrint({
        from: account?.address,
        to,
        value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
        data,
        gas,
        gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
        maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
        maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
        nonce
      });
      super(cause.shortMessage, {
        cause,
        docsPath: docsPath9,
        metaMessages: [
          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
          "Estimate Gas Arguments:",
          prettyArgs
        ].filter(Boolean),
        name: "EstimateGasExecutionError"
      });
      Object.defineProperty(this, "cause", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.cause = cause;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
  init_node();
  init_getNodeError();
  function getEstimateGasError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new EstimateGasExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  init_extract();
  init_transactionRequest();
  init_stateOverride2();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/fee.js
  init_formatGwei();
  init_base();
  var BaseFeeScalarError = class extends BaseError2 {
    constructor() {
      super("`baseFeeMultiplier` must be greater than 1.", {
        name: "BaseFeeScalarError"
      });
    }
  };
  var Eip1559FeesNotSupportedError = class extends BaseError2 {
    constructor() {
      super("Chain does not support EIP-1559 fees.", {
        name: "Eip1559FeesNotSupportedError"
      });
    }
  };
  var MaxFeePerGasTooLowError = class extends BaseError2 {
    constructor({ maxPriorityFeePerGas }) {
      super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/block.js
  init_base();
  var BlockNotFoundError = class extends BaseError2 {
    constructor({ blockHash, blockNumber }) {
      let identifier = "Block";
      if (blockHash)
        identifier = `Block at hash "${blockHash}"`;
      if (blockNumber)
        identifier = `Block at number "${blockNumber}"`;
      super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  init_formatter();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transaction.js
  init_fromHex();
  init_formatter();
  var transactionType = {
    "0x0": "legacy",
    "0x1": "eip2930",
    "0x2": "eip1559",
    "0x3": "eip4844",
    "0x4": "eip7702"
  };
  function formatTransaction(transaction) {
    const transaction_ = {
      ...transaction,
      blockHash: transaction.blockHash ? transaction.blockHash : null,
      blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
      chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
      gas: transaction.gas ? BigInt(transaction.gas) : void 0,
      gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
      maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
      maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
      maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
      nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
      to: transaction.to ? transaction.to : null,
      transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
      type: transaction.type ? transactionType[transaction.type] : void 0,
      typeHex: transaction.type ? transaction.type : void 0,
      value: transaction.value ? BigInt(transaction.value) : void 0,
      v: transaction.v ? BigInt(transaction.v) : void 0
    };
    if (transaction.authorizationList)
      transaction_.authorizationList = formatAuthorizationList2(transaction.authorizationList);
    transaction_.yParity = (() => {
      if (transaction.yParity)
        return Number(transaction.yParity);
      if (typeof transaction_.v === "bigint") {
        if (transaction_.v === 0n || transaction_.v === 27n)
          return 0;
        if (transaction_.v === 1n || transaction_.v === 28n)
          return 1;
        if (transaction_.v >= 35n)
          return transaction_.v % 2n === 0n ? 1 : 0;
      }
      return void 0;
    })();
    if (transaction_.type === "legacy") {
      delete transaction_.accessList;
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
      delete transaction_.yParity;
    }
    if (transaction_.type === "eip2930") {
      delete transaction_.maxFeePerBlobGas;
      delete transaction_.maxFeePerGas;
      delete transaction_.maxPriorityFeePerGas;
    }
    if (transaction_.type === "eip1559") {
      delete transaction_.maxFeePerBlobGas;
    }
    return transaction_;
  }
  var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
  function formatAuthorizationList2(authorizationList) {
    return authorizationList.map((authorization) => ({
      contractAddress: authorization.address,
      chainId: Number(authorization.chainId),
      nonce: Number(authorization.nonce),
      r: authorization.r,
      s: authorization.s,
      yParity: Number(authorization.yParity)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/block.js
  function formatBlock(block) {
    const transactions = block.transactions?.map((transaction) => {
      if (typeof transaction === "string")
        return transaction;
      return formatTransaction(transaction);
    });
    return {
      ...block,
      baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
      blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
      difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
      excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
      gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
      gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
      hash: block.hash ? block.hash : null,
      logsBloom: block.logsBloom ? block.logsBloom : null,
      nonce: block.nonce ? block.nonce : null,
      number: block.number ? BigInt(block.number) : null,
      size: block.size ? BigInt(block.size) : void 0,
      timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
      transactions,
      totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
    };
  }
  var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlock.js
  async function getBlock(client, { blockHash, blockNumber, blockTag: blockTag_, includeTransactions: includeTransactions_ } = {}) {
    const blockTag = blockTag_ ?? "latest";
    const includeTransactions = includeTransactions_ ?? false;
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let block = null;
    if (blockHash) {
      block = await client.request({
        method: "eth_getBlockByHash",
        params: [blockHash, includeTransactions]
      }, { dedupe: true });
    } else {
      block = await client.request({
        method: "eth_getBlockByNumber",
        params: [blockNumberHex || blockTag, includeTransactions]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!block)
      throw new BlockNotFoundError({ blockHash, blockNumber });
    const format = client.chain?.formatters?.block?.format || formatBlock;
    return format(block);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getGasPrice.js
  async function getGasPrice(client) {
    const gasPrice = await client.request({
      method: "eth_gasPrice"
    });
    return BigInt(gasPrice);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
  async function estimateMaxPriorityFeePerGas(client, args) {
    return internal_estimateMaxPriorityFeePerGas(client, args);
  }
  async function internal_estimateMaxPriorityFeePerGas(client, args) {
    const { block: block_, chain = client.chain, request } = args || {};
    try {
      const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
      if (typeof maxPriorityFeePerGas === "function") {
        const block = block_ || await getAction(client, getBlock, "getBlock")({});
        const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
          block,
          client,
          request
        });
        if (maxPriorityFeePerGas_ === null)
          throw new Error();
        return maxPriorityFeePerGas_;
      }
      if (typeof maxPriorityFeePerGas !== "undefined")
        return maxPriorityFeePerGas;
      const maxPriorityFeePerGasHex = await client.request({
        method: "eth_maxPriorityFeePerGas"
      });
      return hexToBigInt(maxPriorityFeePerGasHex);
    } catch {
      const [block, gasPrice] = await Promise.all([
        block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
        getAction(client, getGasPrice, "getGasPrice")({})
      ]);
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
      if (maxPriorityFeePerGas < 0n)
        return 0n;
      return maxPriorityFeePerGas;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
  async function estimateFeesPerGas(client, args) {
    return internal_estimateFeesPerGas(client, args);
  }
  async function internal_estimateFeesPerGas(client, args) {
    const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
    const baseFeeMultiplier = await (async () => {
      if (typeof chain?.fees?.baseFeeMultiplier === "function")
        return chain.fees.baseFeeMultiplier({
          block: block_,
          client,
          request
        });
      return chain?.fees?.baseFeeMultiplier ?? 1.2;
    })();
    if (baseFeeMultiplier < 1)
      throw new BaseFeeScalarError();
    const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
    const denominator = 10 ** decimals;
    const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
    const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
    if (typeof chain?.fees?.estimateFeesPerGas === "function") {
      const fees2 = await chain.fees.estimateFeesPerGas({
        block: block_,
        client,
        multiply,
        request,
        type
      });
      if (fees2 !== null)
        return fees2;
    }
    if (type === "eip1559") {
      if (typeof block.baseFeePerGas !== "bigint")
        throw new Eip1559FeesNotSupportedError();
      const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
        block,
        chain,
        request
      });
      const baseFeePerGas = multiply(block.baseFeePerGas);
      const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    }
    const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
    return {
      gasPrice
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
    const count = await client.request({
      method: "eth_getTransactionCount",
      params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
    }, { dedupe: Boolean(blockNumber) });
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
  init_toBytes();
  init_toHex();
  function blobsToCommitments(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = [];
    for (const blob of blobs)
      commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
    return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/blobsToProofs.js
  init_toBytes();
  init_toHex();
  function blobsToProofs(parameters) {
    const { kzg } = parameters;
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
    const proofs = [];
    for (let i = 0; i < blobs.length; i++) {
      const blob = blobs[i];
      const commitment = commitments[i];
      proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
    }
    return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/sha256.js
  init_sha256();
  init_isHex();
  init_toBytes();
  init_toHex();
  function sha2562(value, to_) {
    const to = to_ || "hex";
    const bytes2 = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
  function commitmentToVersionedHash(parameters) {
    const { commitment, version: version3 = 1 } = parameters;
    const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
    const versionedHash = sha2562(commitment, "bytes");
    versionedHash.set([version3], 0);
    return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
  function commitmentsToVersionedHashes(parameters) {
    const { commitments, version: version3 } = parameters;
    const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const commitment of commitments) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/blob.js
  var blobsPerTransaction = 6;
  var bytesPerFieldElement = 32;
  var fieldElementsPerBlob = 4096;
  var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
  var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
  1 - // zero byte (0x00) appended to each field element.
  1 * fieldElementsPerBlob * blobsPerTransaction;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/kzg.js
  var versionedHashVersionKzg = 1;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/blob.js
  init_base();
  var BlobSizeTooLargeError = class extends BaseError2 {
    constructor({ maxSize, size: size3 }) {
      super("Blob size is too large.", {
        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
        name: "BlobSizeTooLargeError"
      });
    }
  };
  var EmptyBlobError = class extends BaseError2 {
    constructor() {
      super("Blob data must not be empty.", { name: "EmptyBlobError" });
    }
  };
  var InvalidVersionedHashSizeError = class extends BaseError2 {
    constructor({ hash: hash3, size: size3 }) {
      super(`Versioned hash "${hash3}" size is invalid.`, {
        metaMessages: ["Expected: 32", `Received: ${size3}`],
        name: "InvalidVersionedHashSizeError"
      });
    }
  };
  var InvalidVersionedHashVersionError = class extends BaseError2 {
    constructor({ hash: hash3, version: version3 }) {
      super(`Versioned hash "${hash3}" version is invalid.`, {
        metaMessages: [
          `Expected: ${versionedHashVersionKzg}`,
          `Received: ${version3}`
        ],
        name: "InvalidVersionedHashVersionError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobs.js
  init_cursor2();
  init_size();
  init_toBytes();
  init_toHex();
  function toBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
    const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
    const size_ = size(data);
    if (!size_)
      throw new EmptyBlobError();
    if (size_ > maxBytesPerTransaction)
      throw new BlobSizeTooLargeError({
        maxSize: maxBytesPerTransaction,
        size: size_
      });
    const blobs = [];
    let active = true;
    let position = 0;
    while (active) {
      const blob = createCursor(new Uint8Array(bytesPerBlob));
      let size3 = 0;
      while (size3 < fieldElementsPerBlob) {
        const bytes2 = data.slice(position, position + (bytesPerFieldElement - 1));
        blob.pushByte(0);
        blob.pushBytes(bytes2);
        if (bytes2.length < 31) {
          blob.pushByte(128);
          active = false;
          break;
        }
        size3++;
        position += 31;
      }
      blobs.push(blob);
    }
    return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
  function toBlobSidecars(parameters) {
    const { data, kzg, to } = parameters;
    const blobs = parameters.blobs ?? toBlobs({ data, to });
    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
    const sidecars = [];
    for (let i = 0; i < blobs.length; i++)
      sidecars.push({
        blob: blobs[i],
        commitment: commitments[i],
        proof: proofs[i]
      });
    return sidecars;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getTransactionType.js
  init_transaction();
  function getTransactionType(transaction) {
    if (transaction.type)
      return transaction.type;
    if (typeof transaction.authorizationList !== "undefined")
      return "eip7702";
    if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
      return "eip4844";
    if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
      return "eip1559";
    }
    if (typeof transaction.gasPrice !== "undefined") {
      if (typeof transaction.accessList !== "undefined")
        return "eip2930";
      return "legacy";
    }
    throw new InvalidSerializableTransactionError({ transaction });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getChainId.js
  init_fromHex();
  async function getChainId(client) {
    const chainIdHex = await client.request({
      method: "eth_chainId"
    }, { dedupe: true });
    return hexToNumber(chainIdHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
  var defaultParameters = [
    "blobVersionedHashes",
    "chainId",
    "fees",
    "gas",
    "nonce",
    "type"
  ];
  async function prepareTransactionRequest(client, args) {
    const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager: nonceManager2, parameters = defaultParameters, type } = args;
    const account = account_ ? parseAccount(account_) : account_;
    const request = { ...args, ...account ? { from: account?.address } : {} };
    let block;
    async function getBlock2() {
      if (block)
        return block;
      block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
      return block;
    }
    let chainId;
    async function getChainId2() {
      if (chainId)
        return chainId;
      if (chain)
        return chain.id;
      if (typeof args.chainId !== "undefined")
        return args.chainId;
      const chainId_ = await getAction(client, getChainId, "getChainId")({});
      chainId = chainId_;
      return chainId;
    }
    if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
      const commitments = blobsToCommitments({ blobs, kzg });
      if (parameters.includes("blobVersionedHashes")) {
        const versionedHashes = commitmentsToVersionedHashes({
          commitments,
          to: "hex"
        });
        request.blobVersionedHashes = versionedHashes;
      }
      if (parameters.includes("sidecars")) {
        const proofs = blobsToProofs({ blobs, commitments, kzg });
        const sidecars = toBlobSidecars({
          blobs,
          commitments,
          proofs,
          to: "hex"
        });
        request.sidecars = sidecars;
      }
    }
    if (parameters.includes("chainId"))
      request.chainId = await getChainId2();
    if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
      if (nonceManager2) {
        const chainId2 = await getChainId2();
        request.nonce = await nonceManager2.consume({
          address: account.address,
          chainId: chainId2,
          client
        });
      } else {
        request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
          address: account.address,
          blockTag: "pending"
        });
      }
    }
    if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
      try {
        request.type = getTransactionType(request);
      } catch {
        const block2 = await getBlock2();
        request.type = typeof block2?.baseFeePerGas === "bigint" ? "eip1559" : "legacy";
      }
    }
    if (parameters.includes("fees")) {
      if (request.type !== "legacy" && request.type !== "eip2930") {
        if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
          const block2 = await getBlock2();
          const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
            block: block2,
            chain,
            request
          });
          if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
            throw new MaxFeePerGasTooLowError({
              maxPriorityFeePerGas
            });
          request.maxPriorityFeePerGas = maxPriorityFeePerGas;
          request.maxFeePerGas = maxFeePerGas;
        }
      } else {
        if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
          throw new Eip1559FeesNotSupportedError();
        const block2 = await getBlock2();
        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
          block: block2,
          chain,
          request,
          type: "legacy"
        });
        request.gasPrice = gasPrice_;
      }
    }
    if (parameters.includes("gas") && typeof gas === "undefined")
      request.gas = await getAction(client, estimateGas, "estimateGas")({
        ...request,
        account: account ? { address: account.address, type: "json-rpc" } : account
      });
    assertRequest(request);
    delete request.parameters;
    return request;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBalance.js
  init_toHex();
  async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const balance = await client.request({
      method: "eth_getBalance",
      params: [address, blockNumberHex || blockTag]
    });
    return BigInt(balance);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateGas.js
  async function estimateGas(client, args) {
    const { account: account_ = client.account } = args;
    const account = account_ ? parseAccount(account_) : void 0;
    try {
      let estimateGas_rpc = function(parameters) {
        const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
        return client.request({
          method: "eth_estimateGas",
          params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
        });
      };
      const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
        ...args,
        parameters: (
          // Some RPC Providers do not compute versioned hashes from blobs. We will need
          // to compute them.
          account?.type === "local" ? void 0 : ["blobVersionedHashes"]
        )
      });
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      const rpcStateOverride = serializeStateOverride(stateOverride);
      const to = await (async () => {
        if (rest.to)
          return rest.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`");
          });
        return void 0;
      })();
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        authorizationList,
        blobs,
        blobVersionedHashes,
        data,
        gas,
        gasPrice,
        maxFeePerBlobGas,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      let estimate = BigInt(await estimateGas_rpc({ block, request, rpcStateOverride }));
      if (authorizationList) {
        const value2 = await getBalance(client, { address: request.from });
        const estimates = await Promise.all(authorizationList.map(async (authorization) => {
          const { contractAddress } = authorization;
          const estimate2 = await estimateGas_rpc({
            block,
            request: {
              authorizationList: void 0,
              data,
              from: account?.address,
              to: contractAddress,
              value: numberToHex(value2)
            },
            rpcStateOverride
          }).catch(() => 100000n);
          return 2n * BigInt(estimate2);
        }));
        estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
      }
      return estimate;
    } catch (err) {
      throw getEstimateGasError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/estimateContractGas.js
  async function estimateContractGas(client, parameters) {
    const { abi: abi2, address, args, functionName, ...request } = parameters;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const gas = await getAction(client, estimateGas, "estimateGas")({
        data,
        to: address,
        ...request
      });
      return gas;
    } catch (error) {
      const account = request.account ? parseAccount(request.account) : void 0;
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/estimateContractGas",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  init_abi();
  init_isAddressEqual();
  init_toBytes();
  init_keccak256();
  init_toEventSelector();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeEventLog.js
  init_abi();
  init_size();
  init_toEventSelector();
  init_cursor();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  var docsPath3 = "/docs/contract/decodeEventLog";
  function decodeEventLog(parameters) {
    const { abi: abi2, data, strict: strict_, topics } = parameters;
    const strict = strict_ ?? true;
    const [signature, ...argTopics] = topics;
    if (!signature)
      throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
    const abiItem = (() => {
      if (abi2.length === 1)
        return abi2[0];
      return abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x)));
    })();
    if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
      throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
    const { name, inputs } = abiItem;
    const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
    let args = isUnnamed ? [] : {};
    const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
    for (let i = 0; i < indexedInputs.length; i++) {
      const param = indexedInputs[i];
      const topic = argTopics[i];
      if (!topic)
        throw new DecodeLogTopicsMismatch({
          abiItem,
          param
        });
      args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });
    }
    const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
    if (nonIndexedInputs.length > 0) {
      if (data && data !== "0x") {
        try {
          const decodedData = decodeAbiParameters(nonIndexedInputs, data);
          if (decodedData) {
            if (isUnnamed)
              args = [...args, ...decodedData];
            else {
              for (let i = 0; i < nonIndexedInputs.length; i++) {
                args[nonIndexedInputs[i].name] = decodedData[i];
              }
            }
          }
        } catch (err) {
          if (strict) {
            if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
              throw new DecodeLogDataMismatch({
                abiItem,
                data,
                params: nonIndexedInputs,
                size: size(data)
              });
            throw err;
          }
        }
      } else if (strict) {
        throw new DecodeLogDataMismatch({
          abiItem,
          data: "0x",
          params: nonIndexedInputs,
          size: 0
        });
      }
    }
    return {
      eventName: name,
      args: Object.values(args).length > 0 ? args : void 0
    };
  }
  function decodeTopic({ param, value }) {
    if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
      return value;
    const decodedArg = decodeAbiParameters([param], value) || [];
    return decodedArg[0];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/parseEventLogs.js
  function parseEventLogs(parameters) {
    const { abi: abi2, args, logs, strict = true } = parameters;
    const eventName = (() => {
      if (!parameters.eventName)
        return void 0;
      if (Array.isArray(parameters.eventName))
        return parameters.eventName;
      return [parameters.eventName];
    })();
    return logs.map((log) => {
      try {
        const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
        if (!abiItem)
          return null;
        const event = decodeEventLog({
          ...log,
          abi: [abiItem],
          strict
        });
        if (eventName && !eventName.includes(event.eventName))
          return null;
        if (!includesArgs({
          args: event.args,
          inputs: abiItem.inputs,
          matchArgs: args
        }))
          return null;
        return { ...event, ...log };
      } catch (err) {
        let eventName2;
        let isUnnamed;
        if (err instanceof AbiEventSignatureNotFoundError)
          return null;
        if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
          if (strict)
            return null;
          eventName2 = err.abiItem.name;
          isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
        }
        return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
      }
    }).filter(Boolean);
  }
  function includesArgs(parameters) {
    const { args, inputs, matchArgs } = parameters;
    if (!matchArgs)
      return true;
    if (!args)
      return false;
    function isEqual(input, value, arg) {
      try {
        if (input.type === "address")
          return isAddressEqual(value, arg);
        if (input.type === "string" || input.type === "bytes")
          return keccak256(toBytes(value)) === arg;
        return value === arg;
      } catch {
        return false;
      }
    }
    if (Array.isArray(args) && Array.isArray(matchArgs)) {
      return matchArgs.every((value, index2) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs[index2];
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[index2]));
      });
    }
    if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
      return Object.entries(matchArgs).every(([key, value]) => {
        if (value === null || value === void 0)
          return true;
        const input = inputs.find((input2) => input2.name === key);
        if (!input)
          return false;
        const value_ = Array.isArray(value) ? value : [value];
        return value_.some((value2) => isEqual(input, value2, args[key]));
      });
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/log.js
  function formatLog(log, { args, eventName } = {}) {
    return {
      ...log,
      blockHash: log.blockHash ? log.blockHash : null,
      blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
      logIndex: log.logIndex ? Number(log.logIndex) : null,
      transactionHash: log.transactionHash ? log.transactionHash : null,
      transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
      ...eventName ? { args, eventName } : {}
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getLogs.js
  async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
    const strict = strict_ ?? false;
    const events = events_ ?? (event ? [event] : void 0);
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args: events_ ? void 0 : args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    let logs;
    if (blockHash) {
      logs = await client.request({
        method: "eth_getLogs",
        params: [{ address, topics, blockHash }]
      });
    } else {
      logs = await client.request({
        method: "eth_getLogs",
        params: [
          {
            address,
            topics,
            fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
            toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
          }
        ]
      });
    }
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!events)
      return formattedLogs;
    return parseEventLogs({
      abi: events,
      args,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getContractEvents.js
  async function getContractEvents(client, parameters) {
    const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
    const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
    const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
    return getAction(client, getLogs, "getLogs")({
      address,
      args,
      blockHash,
      event,
      events,
      fromBlock,
      toBlock,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/readContract.js
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function readContract(client, parameters) {
    const { abi: abi2, address, args, functionName, ...rest } = parameters;
    const calldata = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      const { data } = await getAction(client, call, "call")({
        ...rest,
        data: calldata,
        to: address
      });
      return decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/readContract",
        functionName
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/simulateContract.js
  init_parseAccount();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_call();
  async function simulateContract(client, parameters) {
    const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
    const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
    const calldata = encodeFunctionData({ abi: abi2, args, functionName });
    try {
      const { data } = await getAction(client, call, "call")({
        batch: false,
        data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        ...callRequest,
        account
      });
      const result = decodeFunctionResult({
        abi: abi2,
        args,
        functionName,
        data: data || "0x"
      });
      const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
      return {
        result,
        request: {
          abi: minimizedAbi,
          address,
          args,
          dataSuffix,
          functionName,
          ...callRequest,
          account
        }
      };
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/simulateContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_abi();
  init_rpc();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/observe.js
  var listenersCache = /* @__PURE__ */ new Map();
  var cleanupCache = /* @__PURE__ */ new Map();
  var callbackCount = 0;
  function observe(observerId, callbacks, fn) {
    const callbackId = ++callbackCount;
    const getListeners = () => listenersCache.get(observerId) || [];
    const unsubscribe = () => {
      const listeners2 = getListeners();
      listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
    };
    const unwatch = () => {
      const cleanup2 = cleanupCache.get(observerId);
      if (getListeners().length === 1 && cleanup2)
        cleanup2();
      unsubscribe();
    };
    const listeners = getListeners();
    listenersCache.set(observerId, [
      ...listeners,
      { id: callbackId, fns: callbacks }
    ]);
    if (listeners && listeners.length > 0)
      return unwatch;
    const emit = {};
    for (const key in callbacks) {
      emit[key] = (...args) => {
        const listeners2 = getListeners();
        if (listeners2.length === 0)
          return;
        for (const listener of listeners2)
          listener.fns[key]?.(...args);
      };
    }
    const cleanup = fn(emit);
    if (typeof cleanup === "function")
      cleanupCache.set(observerId, cleanup);
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/wait.js
  async function wait(time) {
    return new Promise((res) => setTimeout(res, time));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/poll.js
  function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
    let active = true;
    const unwatch = () => active = false;
    const watch = async () => {
      let data = void 0;
      if (emitOnBegin)
        data = await fn({ unpoll: unwatch });
      const initialWait = await initialWaitTime?.(data) ?? interval;
      await wait(initialWait);
      const poll2 = async () => {
        if (!active)
          return;
        await fn({ unpoll: unwatch });
        await wait(interval);
        poll2();
      };
      poll2();
    };
    watch();
    return unwatch;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withCache.js
  var promiseCache = /* @__PURE__ */ new Map();
  var responseCache = /* @__PURE__ */ new Map();
  function getCache(cacheKey2) {
    const buildCache = (cacheKey3, cache) => ({
      clear: () => cache.delete(cacheKey3),
      get: () => cache.get(cacheKey3),
      set: (data) => cache.set(cacheKey3, data)
    });
    const promise = buildCache(cacheKey2, promiseCache);
    const response = buildCache(cacheKey2, responseCache);
    return {
      clear: () => {
        promise.clear();
        response.clear();
      },
      promise,
      response
    };
  }
  async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
    const cache = getCache(cacheKey2);
    const response = cache.response.get();
    if (response && cacheTime > 0) {
      const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
      if (age < cacheTime)
        return response.data;
    }
    let promise = cache.promise.get();
    if (!promise) {
      promise = fn();
      cache.promise.set(promise);
    }
    try {
      const data = await promise;
      cache.response.set({ created: /* @__PURE__ */ new Date(), data });
      return data;
    } finally {
      cache.promise.clear();
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockNumber.js
  var cacheKey = (id) => `blockNumber.${id}`;
  async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
    const blockNumberHex = await withCache(() => client.request({
      method: "eth_blockNumber"
    }), { cacheKey: cacheKey(client.uid), cacheTime });
    return BigInt(blockNumberHex);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterChanges.js
  async function getFilterChanges(_client, { filter }) {
    const strict = "strict" in filter && filter.strict;
    const logs = await filter.request({
      method: "eth_getFilterChanges",
      params: [filter.id]
    });
    if (typeof logs[0] === "string")
      return logs;
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!("abi" in filter) || !filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/uninstallFilter.js
  async function uninstallFilter(_client, { filter }) {
    return filter.request({
      method: "eth_uninstallFilter",
      params: [filter.id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchContractEvent.js
  function watchContractEvent(client, parameters) {
    const { abi: abi2, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const pollContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                args,
                eventName,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber < blockNumber) {
                logs = await getAction(client, getContractEvents, "getContractEvents")({
                  abi: abi2,
                  address,
                  args,
                  eventName,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber,
                  strict
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeContractEvent = () => {
      const strict = strict_ ?? false;
      const observerId = stringify([
        "watchContractEvent",
        address,
        args,
        batch,
        client.uid,
        eventName,
        pollingInterval,
        strict
      ]);
      let active = true;
      let unsubscribe = () => active = false;
      return observe(observerId, { onLogs, onError }, (emit) => {
        ;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const topics = eventName ? encodeEventTopics({
              abi: abi2,
              eventName,
              args
            }) : [];
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["logs", { address, topics }],
              onData(data) {
                if (!active)
                  return;
                const log = data.result;
                try {
                  const { eventName: eventName2, args: args2 } = decodeEventLog({
                    abi: abi2,
                    data: log.data,
                    topics: log.topics,
                    strict: strict_
                  });
                  const formatted = formatLog(log, {
                    args: args2,
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                } catch (err) {
                  let eventName2;
                  let isUnnamed;
                  if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                    if (strict_)
                      return;
                    eventName2 = err.abiItem.name;
                    isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                  }
                  const formatted = formatLog(log, {
                    args: isUnnamed ? [] : {},
                    eventName: eventName2
                  });
                  emit.onLogs([formatted]);
                }
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollContractEvent() : subscribeContractEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/account.js
  init_base();
  var AccountNotFoundError = class extends BaseError2 {
    constructor({ docsPath: docsPath9 } = {}) {
      super([
        "Could not find an Account to execute with this Action.",
        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
      ].join("\n"), {
        docsPath: docsPath9,
        docsSlug: "account",
        name: "AccountNotFoundError"
      });
    }
  };
  var AccountTypeNotSupportedError = class extends BaseError2 {
    constructor({ docsPath: docsPath9, metaMessages, type }) {
      super(`Account type "${type}" is not supported.`, {
        docsPath: docsPath9,
        metaMessages,
        name: "AccountTypeNotSupportedError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_parseAccount();
  init_base();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
  init_chain();
  function assertCurrentChain({ chain, currentChainId }) {
    if (!chain)
      throw new ChainNotFoundError();
    if (currentChainId !== chain.id)
      throw new ChainMismatchError({ chain, currentChainId });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/errors/getTransactionError.js
  init_node();
  init_transaction();
  init_getNodeError();
  function getTransactionError(err, { docsPath: docsPath9, ...args }) {
    const cause = (() => {
      const cause2 = getNodeError(err, args);
      if (cause2 instanceof UnknownNodeError)
        return err;
      return cause2;
    })();
    return new TransactionExecutionError(cause, {
      docsPath: docsPath9,
      ...args
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  init_extract();
  init_transactionRequest();
  init_lru();
  init_assertRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
  async function sendRawTransaction(client, { serializedTransaction }) {
    return client.request({
      method: "eth_sendRawTransaction",
      params: [serializedTransaction]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/sendTransaction.js
  var supportsWalletNamespace = new LruMap(128);
  async function sendTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, ...rest } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/sendTransaction"
      });
    const account = account_ ? parseAccount(account_) : null;
    try {
      assertRequest(parameters);
      const to = await (async () => {
        if (parameters.to)
          return parameters.to;
        if (authorizationList && authorizationList.length > 0)
          return await recoverAuthorizationAddress({
            authorization: authorizationList[0]
          }).catch(() => {
            throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
          });
        return void 0;
      })();
      if (account?.type === "json-rpc" || account === null) {
        let chainId;
        if (chain !== null) {
          chainId = await getAction(client, getChainId, "getChainId")({});
          assertCurrentChain({
            currentChainId: chainId,
            chain
          });
        }
        const chainFormat = client.chain?.formatters?.transactionRequest?.format;
        const format = chainFormat || formatTransactionRequest;
        const request = format({
          // Pick out extra data that might exist on the chain's transaction request type.
          ...extract(rest, { format: chainFormat }),
          accessList,
          authorizationList,
          blobs,
          chainId,
          data,
          from: account?.address,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          to,
          value
        });
        const method = supportsWalletNamespace.get(client.uid) ? "wallet_sendTransaction" : "eth_sendTransaction";
        try {
          return await client.request({
            method,
            params: [request]
          }, { retryCount: 0 });
        } catch (e) {
          const error = e;
          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError")
            return await client.request({
              method: "wallet_sendTransaction",
              params: [request]
            }, { retryCount: 0 }).then((hash3) => {
              supportsWalletNamespace.set(client.uid, true);
              return hash3;
            });
          throw error;
        }
      }
      if (account?.type === "local") {
        const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
          account,
          accessList,
          authorizationList,
          blobs,
          chain,
          data,
          gas,
          gasPrice,
          maxFeePerBlobGas,
          maxFeePerGas,
          maxPriorityFeePerGas,
          nonce,
          nonceManager: account.nonceManager,
          parameters: [...defaultParameters, "sidecars"],
          value,
          ...rest,
          to
        });
        const serializer = chain?.serializers?.transaction;
        const serializedTransaction = await account.signTransaction(request, {
          serializer
        });
        return await getAction(client, sendRawTransaction, "sendRawTransaction")({
          serializedTransaction
        });
      }
      if (account?.type === "smart")
        throw new AccountTypeNotSupportedError({
          metaMessages: [
            "Consider using the `sendUserOperation` Action instead."
          ],
          docsPath: "/docs/actions/bundler/sendUserOperation",
          type: "smart"
        });
      throw new AccountTypeNotSupportedError({
        docsPath: "/docs/actions/wallet/sendTransaction",
        type: account?.type
      });
    } catch (err) {
      if (err instanceof AccountTypeNotSupportedError)
        throw err;
      throw getTransactionError(err, {
        ...parameters,
        account,
        chain: parameters.chain || void 0
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/writeContract.js
  async function writeContract(client, parameters) {
    const { abi: abi2, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
    if (typeof account_ === "undefined")
      throw new AccountNotFoundError({
        docsPath: "/docs/contract/writeContract"
      });
    const account = account_ ? parseAccount(account_) : null;
    const data = encodeFunctionData({
      abi: abi2,
      args,
      functionName
    });
    try {
      return await getAction(client, sendTransaction, "sendTransaction")({
        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
        to: address,
        account,
        ...request
      });
    } catch (error) {
      throw getContractError(error, {
        abi: abi2,
        address,
        args,
        docsPath: "/docs/contract/writeContract",
        functionName,
        sender: account?.address
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/getContract.js
  function getContract({ abi: abi2, address, client: client_ }) {
    const client = client_;
    const [publicClient, walletClient] = (() => {
      if (!client)
        return [void 0, void 0];
      if ("public" in client && "wallet" in client)
        return [client.public, client.wallet];
      if ("public" in client)
        return [client.public, void 0];
      if ("wallet" in client)
        return [void 0, client.wallet];
      return [client, client];
    })();
    const hasPublicClient = publicClient !== void 0 && publicClient !== null;
    const hasWalletClient = walletClient !== void 0 && walletClient !== null;
    const contract = {};
    let hasReadFunction = false;
    let hasWriteFunction = false;
    let hasEvent = false;
    for (const item of abi2) {
      if (item.type === "function")
        if (item.stateMutability === "view" || item.stateMutability === "pure")
          hasReadFunction = true;
        else
          hasWriteFunction = true;
      else if (item.type === "event")
        hasEvent = true;
      if (hasReadFunction && hasWriteFunction && hasEvent)
        break;
    }
    if (hasPublicClient) {
      if (hasReadFunction)
        contract.read = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, readContract, "readContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasWriteFunction)
        contract.simulate = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(publicClient, simulateContract, "simulateContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
      if (hasEvent) {
        contract.createEventFilter = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.getEvents = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, getContractEvents, "getContractEvents")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
        contract.watchEvent = new Proxy({}, {
          get(_, eventName) {
            return (...parameters) => {
              const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
              const { args, options } = getEventParameters(parameters, abiEvent);
              return getAction(publicClient, watchContractEvent, "watchContractEvent")({
                abi: abi2,
                address,
                eventName,
                args,
                ...options
              });
            };
          }
        });
      }
    }
    if (hasWalletClient) {
      if (hasWriteFunction)
        contract.write = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              return getAction(walletClient, writeContract, "writeContract")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options
              });
            };
          }
        });
    }
    if (hasPublicClient || hasWalletClient) {
      if (hasWriteFunction)
        contract.estimateGas = new Proxy({}, {
          get(_, functionName) {
            return (...parameters) => {
              const { args, options } = getFunctionParameters(parameters);
              const client2 = publicClient ?? walletClient;
              return getAction(client2, estimateContractGas, "estimateContractGas")({
                abi: abi2,
                address,
                functionName,
                args,
                ...options,
                account: options.account ?? walletClient.account
              });
            };
          }
        });
    }
    contract.address = address;
    contract.abi = abi2;
    return contract;
  }
  function getFunctionParameters(values) {
    const hasArgs = values.length && Array.isArray(values[0]);
    const args = hasArgs ? values[0] : [];
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }
  function getEventParameters(values, abiEvent) {
    let hasArgs = false;
    if (Array.isArray(values[0]))
      hasArgs = true;
    else if (values.length === 1) {
      hasArgs = abiEvent.inputs.some((x) => x.indexed);
    } else if (values.length === 2) {
      hasArgs = true;
    }
    const args = hasArgs ? values[0] : void 0;
    const options = (hasArgs ? values[1] : values[0]) ?? {};
    return { args, options };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/eip712.js
  init_base();
  var Eip712DomainNotFoundError = class extends BaseError2 {
    constructor({ address }) {
      super(`No EIP-712 domain found on contract "${address}".`, {
        metaMessages: [
          "Ensure that:",
          `- The contract is deployed at the address "${address}".`,
          "- `eip712Domain()` function exists on the contract.",
          "- `eip712Domain()` function matches signature to ERC-5267 specification."
        ],
        name: "Eip712DomainNotFoundError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getEip712Domain.js
  async function getEip712Domain(client, parameters) {
    const { address, factory, factoryData } = parameters;
    try {
      const [fields, name, version3, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
        abi,
        address,
        functionName: "eip712Domain",
        factory,
        factoryData
      });
      return {
        domain: {
          name,
          version: version3,
          chainId: Number(chainId),
          verifyingContract,
          salt
        },
        extensions,
        fields
      };
    } catch (e) {
      const error = e;
      if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
        throw new Eip712DomainNotFoundError({ address });
      }
      throw error;
    }
  }
  var abi = [
    {
      inputs: [],
      name: "eip712Domain",
      outputs: [
        { name: "fields", type: "bytes1" },
        { name: "name", type: "string" },
        { name: "version", type: "string" },
        { name: "chainId", type: "uint256" },
        { name: "verifyingContract", type: "address" },
        { name: "salt", type: "bytes32" },
        { name: "extensions", type: "uint256[]" }
      ],
      stateMutability: "view",
      type: "function"
    }
  ];

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/addChain.js
  init_toHex();
  async function addChain(client, { chain }) {
    const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
    await client.request({
      method: "wallet_addEthereumChain",
      params: [
        {
          chainId: numberToHex(id),
          chainName: name,
          nativeCurrency,
          rpcUrls: rpcUrls.default.http,
          blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
        }
      ]
    }, { dedupe: true, retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  init_parseAccount();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/uid.js
  var size2 = 256;
  var index = size2;
  var buffer;
  function uid(length = 11) {
    if (!buffer || index + length > size2 * 2) {
      buffer = "";
      index = 0;
      for (let i = 0; i < size2; i++) {
        buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
      }
    }
    return buffer.substring(index, index++ + length);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createClient.js
  function createClient(parameters) {
    const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
    const chain = parameters.chain;
    const account = parameters.account ? parseAccount(parameters.account) : void 0;
    const { config, request, value } = parameters.transport({
      chain,
      pollingInterval
    });
    const transport = { ...config, ...value };
    const client = {
      account,
      batch,
      cacheTime,
      ccipRead,
      chain,
      key,
      name,
      pollingInterval,
      request,
      transport,
      type,
      uid: uid()
    };
    function extend(base2) {
      return (extendFn) => {
        const extended = extendFn(base2);
        for (const key2 in client)
          delete extended[key2];
        const combined = { ...base2, ...extended };
        return Object.assign(combined, { extend: extend(combined) });
      };
    }
    return Object.assign(client, { extend: extend(client) });
  }
  function rpcSchema() {
    return null;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_base();
  init_request();
  init_rpc();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withDedupe.js
  init_lru();
  var promiseCache2 = /* @__PURE__ */ new LruMap(8192);
  function withDedupe(fn, { enabled = true, id }) {
    if (!enabled || !id)
      return fn();
    if (promiseCache2.get(id))
      return promiseCache2.get(id);
    const promise = fn().finally(() => promiseCache2.delete(id));
    promiseCache2.set(id, promise);
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withRetry.js
  function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
    return new Promise((resolve, reject) => {
      const attemptRetry = async ({ count = 0 } = {}) => {
        const retry = async ({ error }) => {
          const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
          if (delay)
            await wait(delay);
          attemptRetry({ count: count + 1 });
        };
        try {
          const data = await fn();
          resolve(data);
        } catch (err) {
          if (count < retryCount && await shouldRetry2({ count, error: err }))
            return retry({ error: err });
          reject(err);
        }
      };
      attemptRetry();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/buildRequest.js
  init_stringify();
  function buildRequest(request, options = {}) {
    return async (args, overrideOptions = {}) => {
      const { dedupe = false, retryDelay = 150, retryCount = 3, uid: uid2 } = {
        ...options,
        ...overrideOptions
      };
      const requestId = dedupe ? keccak256(stringToHex(`${uid2}.${stringify(args)}`)) : void 0;
      return withDedupe(() => withRetry(async () => {
        try {
          return await request(args);
        } catch (err_) {
          const err = err_;
          switch (err.code) {
            // -32700
            case ParseRpcError.code:
              throw new ParseRpcError(err);
            // -32600
            case InvalidRequestRpcError.code:
              throw new InvalidRequestRpcError(err);
            // -32601
            case MethodNotFoundRpcError.code:
              throw new MethodNotFoundRpcError(err, { method: args.method });
            // -32602
            case InvalidParamsRpcError.code:
              throw new InvalidParamsRpcError(err);
            // -32603
            case InternalRpcError.code:
              throw new InternalRpcError(err);
            // -32000
            case InvalidInputRpcError.code:
              throw new InvalidInputRpcError(err);
            // -32001
            case ResourceNotFoundRpcError.code:
              throw new ResourceNotFoundRpcError(err);
            // -32002
            case ResourceUnavailableRpcError.code:
              throw new ResourceUnavailableRpcError(err);
            // -32003
            case TransactionRejectedRpcError.code:
              throw new TransactionRejectedRpcError(err);
            // -32004
            case MethodNotSupportedRpcError.code:
              throw new MethodNotSupportedRpcError(err, {
                method: args.method
              });
            // -32005
            case LimitExceededRpcError.code:
              throw new LimitExceededRpcError(err);
            // -32006
            case JsonRpcVersionUnsupportedError.code:
              throw new JsonRpcVersionUnsupportedError(err);
            // 4001
            case UserRejectedRequestError.code:
              throw new UserRejectedRequestError(err);
            // 4100
            case UnauthorizedProviderError.code:
              throw new UnauthorizedProviderError(err);
            // 4200
            case UnsupportedProviderMethodError.code:
              throw new UnsupportedProviderMethodError(err);
            // 4900
            case ProviderDisconnectedError.code:
              throw new ProviderDisconnectedError(err);
            // 4901
            case ChainDisconnectedError.code:
              throw new ChainDisconnectedError(err);
            // 4902
            case SwitchChainError.code:
              throw new SwitchChainError(err);
            // CAIP-25: User Rejected Error
            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
            case 5e3:
              throw new UserRejectedRequestError(err);
            default:
              if (err_ instanceof BaseError2)
                throw err_;
              throw new UnknownRpcError(err);
          }
        }
      }, {
        delay: ({ count, error }) => {
          if (error && error instanceof HttpRequestError) {
            const retryAfter = error?.headers?.get("Retry-After");
            if (retryAfter?.match(/\d/))
              return Number.parseInt(retryAfter) * 1e3;
          }
          return ~~(1 << count) * retryDelay;
        },
        retryCount,
        shouldRetry: ({ error }) => shouldRetry(error)
      }), { enabled: dedupe, id: requestId });
    };
  }
  function shouldRetry(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === -1)
        return true;
      if (error.code === LimitExceededRpcError.code)
        return true;
      if (error.code === InternalRpcError.code)
        return true;
      return false;
    }
    if (error instanceof HttpRequestError && error.status) {
      if (error.status === 403)
        return true;
      if (error.status === 408)
        return true;
      if (error.status === 413)
        return true;
      if (error.status === 429)
        return true;
      if (error.status === 500)
        return true;
      if (error.status === 502)
        return true;
      if (error.status === 503)
        return true;
      if (error.status === 504)
        return true;
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/createTransport.js
  function createTransport({ key, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
    const uid2 = uid();
    return {
      config: {
        key,
        name,
        request,
        retryCount,
        retryDelay,
        timeout,
        type
      },
      request: buildRequest(request, { retryCount, retryDelay, uid: uid2 }),
      value
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/custom.js
  function custom(provider, config = {}) {
    const { key = "custom", name = "Custom Provider", retryDelay } = config;
    return ({ retryCount: defaultRetryCount }) => createTransport({
      key,
      name,
      request: provider.request.bind(provider),
      retryCount: config.retryCount ?? defaultRetryCount,
      retryDelay,
      type: "custom"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/fallback.js
  init_rpc();
  function fallback(transports_, config = {}) {
    const { key = "fallback", name = "Fallback", rank = false, retryCount, retryDelay } = config;
    return ({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
      let transports = transports_;
      let onResponse = () => {
      };
      const transport = createTransport({
        key,
        name,
        async request({ method, params }) {
          const fetch2 = async (i = 0) => {
            const transport2 = transports[i]({
              ...rest,
              chain,
              retryCount: 0,
              timeout
            });
            try {
              const response = await transport2.request({
                method,
                params
              });
              onResponse({
                method,
                params,
                response,
                transport: transport2,
                status: "success"
              });
              return response;
            } catch (err) {
              onResponse({
                error: err,
                method,
                params,
                transport: transport2,
                status: "error"
              });
              if (shouldThrow(err))
                throw err;
              if (i === transports.length - 1)
                throw err;
              return fetch2(i + 1);
            }
          };
          return fetch2();
        },
        retryCount,
        retryDelay,
        type: "fallback"
      }, {
        onResponse: (fn) => onResponse = fn,
        transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
      });
      if (rank) {
        const rankOptions = typeof rank === "object" ? rank : {};
        rankTransports({
          chain,
          interval: rankOptions.interval ?? pollingInterval,
          onTransports: (transports_2) => transports = transports_2,
          sampleCount: rankOptions.sampleCount,
          timeout: rankOptions.timeout,
          transports,
          weights: rankOptions.weights
        });
      }
      return transport;
    };
  }
  function shouldThrow(error) {
    if ("code" in error && typeof error.code === "number") {
      if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === 5e3)
        return true;
    }
    return false;
  }
  function rankTransports({ chain, interval = 4e3, onTransports, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
    const samples = [];
    const rankTransports_ = async () => {
      const sample = await Promise.all(transports.map(async (transport) => {
        const transport_ = transport({ chain, retryCount: 0, timeout });
        const start = Date.now();
        let end;
        let success;
        try {
          await transport_.request({ method: "net_listening" });
          success = 1;
        } catch {
          success = 0;
        } finally {
          end = Date.now();
        }
        const latency = end - start;
        return { latency, success };
      }));
      samples.push(sample);
      if (samples.length > sampleCount)
        samples.shift();
      const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
      const scores = transports.map((_, i) => {
        const latencies = samples.map((sample2) => sample2[i].latency);
        const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
        const latencyScore = 1 - meanLatency / maxLatency;
        const successes = samples.map((sample2) => sample2[i].success);
        const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
        if (stabilityScore === 0)
          return [0, i];
        return [
          latencyWeight * latencyScore + stabilityWeight * stabilityScore,
          i
        ];
      }).sort((a, b) => b[0] - a[0]);
      onTransports(scores.map(([, i]) => transports[i]));
      await wait(interval);
      rankTransports_();
    };
    rankTransports_();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/transport.js
  init_base();
  var UrlRequiredError = class extends BaseError2 {
    constructor() {
      super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
        docsPath: "/docs/clients/intro",
        name: "UrlRequiredError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  init_createBatchScheduler();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/promise/withTimeout.js
  function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
    return new Promise((resolve, reject) => {
      ;
      (async () => {
        let timeoutId;
        try {
          const controller = new AbortController();
          if (timeout > 0) {
            timeoutId = setTimeout(() => {
              if (signal) {
                controller.abort();
              } else {
                reject(errorInstance);
              }
            }, timeout);
          }
          resolve(await fn({ signal: controller?.signal || null }));
        } catch (err) {
          if (err?.name === "AbortError")
            reject(errorInstance);
          reject(err);
        } finally {
          clearTimeout(timeoutId);
        }
      })();
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/id.js
  function createIdStore() {
    return {
      current: 0,
      take() {
        return this.current++;
      },
      reset() {
        this.current = 0;
      }
    };
  }
  var idCache = /* @__PURE__ */ createIdStore();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/http.js
  function getHttpRpcClient(url, options = {}) {
    return {
      async request(params) {
        const { body, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
        const fetchOptions = {
          ...options.fetchOptions ?? {},
          ...params.fetchOptions ?? {}
        };
        const { headers, method, signal: signal_ } = fetchOptions;
        try {
          const response = await withTimeout(async ({ signal }) => {
            const init = {
              ...fetchOptions,
              body: Array.isArray(body) ? stringify(body.map((body2) => ({
                jsonrpc: "2.0",
                id: body2.id ?? idCache.take(),
                ...body2
              }))) : stringify({
                jsonrpc: "2.0",
                id: body.id ?? idCache.take(),
                ...body
              }),
              headers: {
                "Content-Type": "application/json",
                ...headers
              },
              method: method || "POST",
              signal: signal_ || (timeout > 0 ? signal : null)
            };
            const request = new Request(url, init);
            const args = await onRequest?.(request, init) ?? { ...init, url };
            const response2 = await fetch(args.url ?? url, args);
            return response2;
          }, {
            errorInstance: new TimeoutError({ body, url }),
            timeout,
            signal: true
          });
          if (onResponse)
            await onResponse(response);
          let data;
          if (response.headers.get("Content-Type")?.startsWith("application/json"))
            data = await response.json();
          else {
            data = await response.text();
            try {
              data = JSON.parse(data || "{}");
            } catch (err) {
              if (response.ok)
                throw err;
              data = { error: data };
            }
          }
          if (!response.ok) {
            throw new HttpRequestError({
              body,
              details: stringify(data.error) || response.statusText,
              headers: response.headers,
              status: response.status,
              url
            });
          }
          return data;
        } catch (err) {
          if (err instanceof HttpRequestError)
            throw err;
          if (err instanceof TimeoutError)
            throw err;
          throw new HttpRequestError({
            body,
            cause: err,
            url
          });
        }
      }
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/http.js
  function http(url, config = {}) {
    const { batch, fetchOptions, key = "http", name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.http[0];
      if (!url_)
        throw new UrlRequiredError();
      const rpcClient = getHttpRpcClient(url_, {
        fetchOptions,
        onRequest: onFetchRequest,
        onResponse: onFetchResponse,
        timeout
      });
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const { schedule } = createBatchScheduler({
            id: url_,
            wait: wait2,
            shouldSplitBatch(requests) {
              return requests.length > batchSize;
            },
            fn: (body2) => rpcClient.request({
              body: body2
            }),
            sort: (a, b) => a.id - b.id
          });
          const fn = async (body2) => batch ? schedule(body2) : [
            await rpcClient.request({
              body: body2
            })
          ];
          const [{ error, result }] = await fn(body);
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "http"
      }, {
        fetchOptions,
        url: url_
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/errors.js
  init_solidity();
  init_base();
  init_contract();
  function isNullUniversalResolverError(err, callType) {
    if (!(err instanceof BaseError2))
      return false;
    const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (!(cause instanceof ContractFunctionRevertedError))
      return false;
    if (cause.data?.errorName === "ResolverNotFound")
      return true;
    if (cause.data?.errorName === "ResolverWildcardNotSupported")
      return true;
    if (cause.data?.errorName === "ResolverNotContract")
      return true;
    if (cause.data?.errorName === "ResolverError")
      return true;
    if (cause.data?.errorName === "HttpError")
      return true;
    if (cause.reason?.includes("Wildcard on non-extended resolvers is not supported"))
      return true;
    if (callType === "reverse" && cause.reason === panicReasons[50])
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  init_concat();
  init_toBytes();
  init_toHex();
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodedLabelToLabelhash.js
  init_isHex();
  function encodedLabelToLabelhash(label) {
    if (label.length !== 66)
      return null;
    if (label.indexOf("[") !== 0)
      return null;
    if (label.indexOf("]") !== 65)
      return null;
    const hash3 = `0x${label.slice(1, 65)}`;
    if (!isHex(hash3))
      return null;
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/namehash.js
  function namehash(name) {
    let result = new Uint8Array(32).fill(0);
    if (!name)
      return bytesToHex(result);
    const labels = name.split(".");
    for (let i = labels.length - 1; i >= 0; i -= 1) {
      const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
      const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256(stringToBytes(labels[i]), "bytes");
      result = keccak256(concat([result, hashed]), "bytes");
    }
    return bytesToHex(result);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/encodeLabelhash.js
  function encodeLabelhash(hash3) {
    return `[${hash3.slice(2)}]`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/labelhash.js
  init_toBytes();
  init_toHex();
  init_keccak256();
  function labelhash(label) {
    const result = new Uint8Array(32).fill(0);
    if (!label)
      return bytesToHex(result);
    return encodedLabelToLabelhash(label) || keccak256(stringToBytes(label));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/packetToBytes.js
  function packetToBytes(packet) {
    const value = packet.replace(/^\.|\.$/gm, "");
    if (value.length === 0)
      return new Uint8Array(1);
    const bytes2 = new Uint8Array(stringToBytes(value).byteLength + 2);
    let offset = 0;
    const list = value.split(".");
    for (let i = 0; i < list.length; i++) {
      let encoded = stringToBytes(list[i]);
      if (encoded.byteLength > 255)
        encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
      bytes2[offset] = encoded.length;
      bytes2.set(encoded, offset + 1);
      offset += encoded.length + 1;
    }
    if (bytes2.byteLength !== offset + 1)
      return bytes2.slice(0, offset + 1);
    return bytes2;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAddress.js
  async function getEnsAddress(client, { blockNumber, blockTag, coinType, name, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const functionData = encodeFunctionData({
        abi: addressResolverAbi,
        functionName: "addr",
        ...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
      });
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [toHex(packetToBytes(name)), functionData],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const address = decodeFunctionResult({
        abi: addressResolverAbi,
        args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
        functionName: "addr",
        data: res[0]
      });
      if (address === "0x")
        return null;
      if (trim(address) === "0x00")
        return null;
      return address;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/ens.js
  init_base();
  var EnsAvatarInvalidMetadataError = class extends BaseError2 {
    constructor({ data }) {
      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
        metaMessages: [
          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
          "",
          `Provided data: ${JSON.stringify(data)}`
        ],
        name: "EnsAvatarInvalidMetadataError"
      });
    }
  };
  var EnsAvatarInvalidNftUriError = class extends BaseError2 {
    constructor({ reason }) {
      super(`ENS NFT avatar URI is invalid. ${reason}`, {
        name: "EnsAvatarInvalidNftUriError"
      });
    }
  };
  var EnsAvatarUriResolutionError = class extends BaseError2 {
    constructor({ uri }) {
      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
    }
  };
  var EnsAvatarUnsupportedNamespaceError = class extends BaseError2 {
    constructor({ namespace }) {
      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/utils.js
  var networkRegex = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
  async function isImageUri(uri) {
    try {
      const res = await fetch(uri, { method: "HEAD" });
      if (res.status === 200) {
        const contentType = res.headers.get("content-type");
        return contentType?.startsWith("image/");
      }
      return false;
    } catch (error) {
      if (typeof error === "object" && typeof error.response !== "undefined") {
        return false;
      }
      if (!globalThis.hasOwnProperty("Image"))
        return false;
      return new Promise((resolve) => {
        const img = new Image();
        img.onload = () => {
          resolve(true);
        };
        img.onerror = () => {
          resolve(false);
        };
        img.src = uri;
      });
    }
  }
  function getGateway(custom2, defaultGateway) {
    if (!custom2)
      return defaultGateway;
    if (custom2.endsWith("/"))
      return custom2.slice(0, -1);
    return custom2;
  }
  function resolveAvatarUri({ uri, gatewayUrls }) {
    const isEncoded = base64Regex.test(uri);
    if (isEncoded)
      return { uri, isOnChain: true, isEncoded };
    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
    const networkRegexMatch = uri.match(networkRegex);
    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
      let replacedUri = uri;
      if (gatewayUrls?.arweave)
        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
      return { uri: replacedUri, isOnChain: false, isEncoded: false };
    }
    if ((isIPNS || isIPFS) && target) {
      return {
        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    if (protocol === "ar:/" && target) {
      return {
        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
        isOnChain: false,
        isEncoded: false
      };
    }
    let parsedUri = uri.replace(dataURIRegex, "");
    if (parsedUri.startsWith("<svg")) {
      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
    }
    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
      return {
        uri: parsedUri,
        isOnChain: true,
        isEncoded: false
      };
    }
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function getJsonImage(data) {
    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
      throw new EnsAvatarInvalidMetadataError({ data });
    }
    return data.image || data.image_url || data.image_data;
  }
  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
    try {
      const res = await fetch(uri).then((res2) => res2.json());
      const image = await parseAvatarUri({
        gatewayUrls,
        uri: getJsonImage(res)
      });
      return image;
    } catch {
      throw new EnsAvatarUriResolutionError({ uri });
    }
  }
  async function parseAvatarUri({ gatewayUrls, uri }) {
    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
    if (isOnChain)
      return resolvedURI;
    const isImage = await isImageUri(resolvedURI);
    if (isImage)
      return resolvedURI;
    throw new EnsAvatarUriResolutionError({ uri });
  }
  function parseNftUri(uri_) {
    let uri = uri_;
    if (uri.startsWith("did:nft:")) {
      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
    }
    const [reference, asset_namespace, tokenID] = uri.split("/");
    const [eip_namespace, chainID] = reference.split(":");
    const [erc_namespace, contractAddress] = asset_namespace.split(":");
    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
    if (!chainID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
    if (!contractAddress)
      throw new EnsAvatarInvalidNftUriError({
        reason: "Contract address not found"
      });
    if (!tokenID)
      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
    if (!erc_namespace)
      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
    return {
      chainID: Number.parseInt(chainID),
      namespace: erc_namespace.toLowerCase(),
      contractAddress,
      tokenID
    };
  }
  async function getNftTokenUri(client, { nft }) {
    if (nft.namespace === "erc721") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "tokenURI",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "tokenId", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "tokenURI",
        args: [BigInt(nft.tokenID)]
      });
    }
    if (nft.namespace === "erc1155") {
      return readContract(client, {
        address: nft.contractAddress,
        abi: [
          {
            name: "uri",
            type: "function",
            stateMutability: "view",
            inputs: [{ name: "_id", type: "uint256" }],
            outputs: [{ name: "", type: "string" }]
          }
        ],
        functionName: "uri",
        args: [BigInt(nft.tokenID)]
      });
    }
    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
  async function parseAvatarRecord(client, { gatewayUrls, record }) {
    if (/eip155:/i.test(record))
      return parseNftAvatarUri(client, { gatewayUrls, record });
    return parseAvatarUri({ uri: record, gatewayUrls });
  }
  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
    const nft = parseNftUri(record);
    const nftUri = await getNftTokenUri(client, { nft });
    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
      const encodedJson = isEncoded ? (
        // if it is encoded, decode it
        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
      ) : (
        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
        resolvedNftUri
      );
      const decoded = JSON.parse(encodedJson);
      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
    }
    let uriTokenId = nft.tokenID;
    if (nft.namespace === "erc1155")
      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
    return getMetadataAvatarUri({
      gatewayUrls,
      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsText.js
  init_abis();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsText(client, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverResolveAbi,
        functionName: "resolve",
        args: [
          toHex(packetToBytes(name)),
          encodeFunctionData({
            abi: textResolverAbi,
            functionName: "text",
            args: [namehash(name), key]
          })
        ],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const res = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (res[0] === "0x")
        return null;
      const record = decodeFunctionResult({
        abi: textResolverAbi,
        functionName: "text",
        data: res[0]
      });
      return record === "" ? null : record;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "resolve"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsAvatar.js
  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
    const record = await getAction(client, getEnsText, "getEnsText")({
      blockNumber,
      blockTag,
      key: "avatar",
      name,
      universalResolverAddress,
      gatewayUrls,
      strict
    });
    if (!record)
      return null;
    try {
      return await parseAvatarRecord(client, {
        record,
        gatewayUrls: assetGatewayUrls
      });
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsName.js
  init_abis();
  init_getChainContractAddress();
  init_toHex();
  async function getEnsName(client, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
    try {
      const readContractParameters = {
        address: universalResolverAddress,
        abi: universalResolverReverseAbi,
        functionName: "reverse",
        args: [toHex(packetToBytes(reverseNode))],
        blockNumber,
        blockTag
      };
      const readContractAction = getAction(client, readContract, "readContract");
      const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
        ...readContractParameters,
        args: [...readContractParameters.args, gatewayUrls]
      }) : await readContractAction(readContractParameters);
      if (address.toLowerCase() !== resolvedAddress.toLowerCase())
        return null;
      return name;
    } catch (err) {
      if (strict)
        throw err;
      if (isNullUniversalResolverError(err, "reverse"))
        return null;
      throw err;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/ens/getEnsResolver.js
  init_getChainContractAddress();
  init_toHex();
  async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_ }) {
    let universalResolverAddress = universalResolverAddress_;
    if (!universalResolverAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. universalResolverAddress is required.");
      universalResolverAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "ensUniversalResolver"
      });
    }
    const [resolverAddress] = await getAction(client, readContract, "readContract")({
      address: universalResolverAddress,
      abi: [
        {
          inputs: [{ type: "bytes" }],
          name: "findResolver",
          outputs: [{ type: "address" }, { type: "bytes32" }],
          stateMutability: "view",
          type: "function"
        }
      ],
      functionName: "findResolver",
      args: [toHex(packetToBytes(name))],
      blockNumber,
      blockTag
    });
    return resolverAddress;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  init_call();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createBlockFilter.js
  async function createBlockFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newBlockFilter"
    });
    const id = await client.request({
      method: "eth_newBlockFilter"
    });
    return { id, request: getRequest(id), type: "block" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createEventFilter.js
  init_toHex();
  async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
    const events = events_ ?? (event ? [event] : void 0);
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newFilter"
    });
    let topics = [];
    if (events) {
      const encoded = events.flatMap((event2) => encodeEventTopics({
        abi: [event2],
        eventName: event2.name,
        args
      }));
      topics = [encoded];
      if (event)
        topics = topics[0];
    }
    const id = await client.request({
      method: "eth_newFilter",
      params: [
        {
          address,
          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
          ...topics.length ? { topics } : {}
        }
      ]
    });
    return {
      abi: events,
      args,
      eventName: event ? event.name : void 0,
      fromBlock,
      id,
      request: getRequest(id),
      strict: Boolean(strict),
      toBlock,
      type: "event"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js
  async function createPendingTransactionFilter(client) {
    const getRequest = createFilterRequestScope(client, {
      method: "eth_newPendingTransactionFilter"
    });
    const id = await client.request({
      method: "eth_newPendingTransactionFilter"
    });
    return { id, request: getRequest(id), type: "transaction" };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlobBaseFee.js
  async function getBlobBaseFee(client) {
    const baseFee = await client.request({
      method: "eth_blobBaseFee"
    });
    return BigInt(baseFee);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getBlockTransactionCount.js
  init_fromHex();
  init_toHex();
  async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let count;
    if (blockHash) {
      count = await client.request({
        method: "eth_getBlockTransactionCountByHash",
        params: [blockHash]
      }, { dedupe: true });
    } else {
      count = await client.request({
        method: "eth_getBlockTransactionCountByNumber",
        params: [blockNumberHex || blockTag]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    return hexToNumber(count);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getCode.js
  init_toHex();
  async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const hex = await client.request({
      method: "eth_getCode",
      params: [address, blockNumberHex || blockTag]
    }, { dedupe: Boolean(blockNumberHex) });
    if (hex === "0x")
      return void 0;
    return hex;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/feeHistory.js
  function formatFeeHistory(feeHistory) {
    return {
      baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
      gasUsedRatio: feeHistory.gasUsedRatio,
      oldestBlock: BigInt(feeHistory.oldestBlock),
      reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFeeHistory.js
  async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
    const feeHistory = await client.request({
      method: "eth_feeHistory",
      params: [
        numberToHex(blockCount),
        blockNumberHex || blockTag,
        rewardPercentiles
      ]
    }, { dedupe: Boolean(blockNumberHex) });
    return formatFeeHistory(feeHistory);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getFilterLogs.js
  async function getFilterLogs(_client, { filter }) {
    const strict = filter.strict ?? false;
    const logs = await filter.request({
      method: "eth_getFilterLogs",
      params: [filter.id]
    });
    const formattedLogs = logs.map((log) => formatLog(log));
    if (!filter.abi)
      return formattedLogs;
    return parseEventLogs({
      abi: filter.abi,
      logs: formattedLogs,
      strict
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/defineChain.js
  function defineChain(chain) {
    return {
      formatters: void 0,
      fees: void 0,
      serializers: void 0,
      ...chain
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/chain/extractChain.js
  function extractChain({ chains, id }) {
    return chains.find((chain) => chain.id === id);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/regex.js
  var arrayRegex = /^(.*)\[([0-9]*)\]$/;
  var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
  var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  init_request();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/socket.js
  init_request();
  init_createBatchScheduler();
  var socketClientCache = /* @__PURE__ */ new Map();
  async function getSocketRpcClient(parameters) {
    const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
    const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
    const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
    let socketClient = socketClientCache.get(`${key}:${url}`);
    if (socketClient)
      return socketClient;
    let reconnectCount = 0;
    const { schedule } = createBatchScheduler({
      id: `${key}:${url}`,
      fn: async () => {
        const requests = /* @__PURE__ */ new Map();
        const subscriptions = /* @__PURE__ */ new Map();
        let error;
        let socket;
        let keepAliveTimer;
        async function setup() {
          const result = await getSocket2({
            onClose() {
              for (const request of requests.values())
                request.onError?.(new SocketClosedError({ url }));
              for (const subscription of subscriptions.values())
                subscription.onError?.(new SocketClosedError({ url }));
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onError(error_) {
              error = error_;
              for (const request of requests.values())
                request.onError?.(error);
              for (const subscription of subscriptions.values())
                subscription.onError?.(error);
              requests.clear();
              subscriptions.clear();
              if (reconnect && reconnectCount < attempts)
                setTimeout(async () => {
                  reconnectCount++;
                  await setup().catch(console.error);
                }, delay);
            },
            onOpen() {
              error = void 0;
              reconnectCount = 0;
            },
            onResponse(data) {
              const isSubscription = data.method === "eth_subscription";
              const id = isSubscription ? data.params.subscription : data.id;
              const cache = isSubscription ? subscriptions : requests;
              const callback = cache.get(id);
              if (callback)
                callback.onResponse(data);
              if (!isSubscription)
                cache.delete(id);
            }
          });
          socket = result;
          if (keepAlive) {
            if (keepAliveTimer)
              clearInterval(keepAliveTimer);
            keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
          }
          return result;
        }
        await setup();
        error = void 0;
        socketClient = {
          close() {
            keepAliveTimer && clearInterval(keepAliveTimer);
            socket.close();
            socketClientCache.delete(`${key}:${url}`);
          },
          get socket() {
            return socket;
          },
          request({ body, onError, onResponse }) {
            if (error && onError)
              onError(error);
            const id = body.id ?? idCache.take();
            const callback = (response) => {
              if (typeof response.id === "number" && id !== response.id)
                return;
              if (body.method === "eth_subscribe" && typeof response.result === "string")
                subscriptions.set(response.result, {
                  onResponse: callback,
                  onError
                });
              if (body.method === "eth_unsubscribe")
                subscriptions.delete(body.params?.[0]);
              onResponse(response);
            };
            requests.set(id, { onResponse: callback, onError });
            try {
              socket.request({
                body: {
                  jsonrpc: "2.0",
                  id,
                  ...body
                }
              });
            } catch (error2) {
              onError?.(error2);
            }
          },
          requestAsync({ body, timeout = 1e4 }) {
            return withTimeout(() => new Promise((onResponse, onError) => this.request({
              body,
              onError,
              onResponse
            })), {
              errorInstance: new TimeoutError({ body, url }),
              timeout
            });
          },
          requests,
          subscriptions,
          url
        };
        socketClientCache.set(`${key}:${url}`, socketClient);
        return [socketClient];
      }
    });
    const [_, [socketClient_]] = await schedule();
    return socketClient_;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/webSocket.js
  async function getWebSocketRpcClient(url, options = {}) {
    const { keepAlive, reconnect } = options;
    return getSocketRpcClient({
      async getSocket({ onClose, onError, onOpen, onResponse }) {
        const WebSocket3 = await Promise.resolve().then(() => (init_native(), native_exports)).then((module) => module.WebSocket);
        const socket = new WebSocket3(url);
        function onClose_() {
          onClose();
          socket.removeEventListener("close", onClose_);
          socket.removeEventListener("message", onMessage);
          socket.removeEventListener("error", onError);
          socket.removeEventListener("open", onOpen);
        }
        function onMessage({ data }) {
          onResponse(JSON.parse(data));
        }
        socket.addEventListener("close", onClose_);
        socket.addEventListener("message", onMessage);
        socket.addEventListener("error", onError);
        socket.addEventListener("open", onOpen);
        if (socket.readyState === WebSocket3.CONNECTING) {
          await new Promise((resolve, reject) => {
            if (!socket)
              return;
            socket.onopen = resolve;
            socket.onerror = reject;
          });
        }
        const { close: close_ } = socket;
        return Object.assign(socket, {
          close() {
            close_.bind(socket)();
            onClose();
          },
          ping() {
            try {
              if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
                throw new WebSocketRequestError({
                  url: socket.url,
                  cause: new SocketClosedError({ url: socket.url })
                });
              const body = {
                jsonrpc: "2.0",
                method: "net_version",
                params: []
              };
              socket.send(JSON.stringify(body));
            } catch (error) {
              onError(error);
            }
          },
          request({ body }) {
            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
              throw new WebSocketRequestError({
                body,
                url: socket.url,
                cause: new SocketClosedError({ url: socket.url })
              });
            return socket.send(JSON.stringify(body));
          }
        });
      },
      keepAlive,
      reconnect,
      url
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/rpc/compat.js
  async function getSocket(url) {
    const client = await getWebSocketRpcClient(url);
    return Object.assign(client.socket, {
      requests: client.requests,
      subscriptions: client.subscriptions
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_abi();
  init_address();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/typedData.js
  init_base();
  var InvalidPrimaryTypeError = class extends BaseError2 {
    constructor({ primaryType, types }) {
      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
        metaMessages: ["Check that the primary type is a key in `types`."]
      });
    }
  };
  var InvalidStructTypeError = class extends BaseError2 {
    constructor({ type }) {
      super(`Struct type "${type}" is invalid.`, {
        metaMessages: ["Struct type must not be a Solidity type."],
        name: "InvalidStructTypeError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_isAddress();
  init_size();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashTypedData.js
  init_encodeAbiParameters();
  init_concat();
  init_toHex();
  init_keccak256();
  function hashTypedData(parameters) {
    const { domain = {}, message, primaryType } = parameters;
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({
      domain,
      message,
      primaryType,
      types
    });
    const parts = ["0x1901"];
    if (domain)
      parts.push(hashDomain({
        domain,
        types
      }));
    if (primaryType !== "EIP712Domain")
      parts.push(hashStruct({
        data: message,
        primaryType,
        types
      }));
    return keccak256(concat(parts));
  }
  function hashDomain({ domain, types }) {
    return hashStruct({
      data: domain,
      primaryType: "EIP712Domain",
      types
    });
  }
  function hashStruct({ data, primaryType, types }) {
    const encoded = encodeData({
      data,
      primaryType,
      types
    });
    return keccak256(encoded);
  }
  function encodeData({ data, primaryType, types }) {
    const encodedTypes = [{ type: "bytes32" }];
    const encodedValues = [hashType({ primaryType, types })];
    for (const field of types[primaryType]) {
      const [type, value] = encodeField({
        types,
        name: field.name,
        type: field.type,
        value: data[field.name]
      });
      encodedTypes.push(type);
      encodedValues.push(value);
    }
    return encodeAbiParameters(encodedTypes, encodedValues);
  }
  function hashType({ primaryType, types }) {
    const encodedHashType = toHex(encodeType({ primaryType, types }));
    return keccak256(encodedHashType);
  }
  function encodeType({ primaryType, types }) {
    let result = "";
    const unsortedDeps = findTypeDependencies({ primaryType, types });
    unsortedDeps.delete(primaryType);
    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
    for (const type of deps) {
      result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
    }
    return result;
  }
  function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
    const match = primaryType_.match(/^\w*/u);
    const primaryType = match?.[0];
    if (results.has(primaryType) || types[primaryType] === void 0) {
      return results;
    }
    results.add(primaryType);
    for (const field of types[primaryType]) {
      findTypeDependencies({ primaryType: field.type, types }, results);
    }
    return results;
  }
  function encodeField({ types, name, type, value }) {
    if (types[type] !== void 0) {
      return [
        { type: "bytes32" },
        keccak256(encodeData({ data: value, primaryType: type, types }))
      ];
    }
    if (type === "bytes") {
      const prepend = value.length % 2 ? "0" : "";
      value = `0x${prepend + value.slice(2)}`;
      return [{ type: "bytes32" }, keccak256(value)];
    }
    if (type === "string")
      return [{ type: "bytes32" }, keccak256(toHex(value))];
    if (type.lastIndexOf("]") === type.length - 1) {
      const parsedType = type.slice(0, type.lastIndexOf("["));
      const typeValuePairs = value.map((item) => encodeField({
        name,
        type: parsedType,
        types,
        value: item
      }));
      return [
        { type: "bytes32" },
        keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
      ];
    }
    return [{ type }, value];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/typedData.js
  init_stringify();
  function serializeTypedData(parameters) {
    const { domain: domain_, message: message_, primaryType, types } = parameters;
    const normalizeData = (struct, data_) => {
      const data = { ...data_ };
      for (const param of struct) {
        const { name, type } = param;
        if (type === "address")
          data[name] = data[name].toLowerCase();
      }
      return data;
    };
    const domain = (() => {
      if (!types.EIP712Domain)
        return {};
      if (!domain_)
        return {};
      return normalizeData(types.EIP712Domain, domain_);
    })();
    const message = (() => {
      if (primaryType === "EIP712Domain")
        return void 0;
      return normalizeData(types[primaryType], message_);
    })();
    return stringify({ domain, message, primaryType, types });
  }
  function validateTypedData(parameters) {
    const { domain, message, primaryType, types } = parameters;
    const validateData = (struct, data) => {
      for (const param of struct) {
        const { name, type } = param;
        const value = data[name];
        const integerMatch = type.match(integerRegex2);
        if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
          const [_type, base2, size_] = integerMatch;
          numberToHex(value, {
            signed: base2 === "int",
            size: Number.parseInt(size_) / 8
          });
        }
        if (type === "address" && typeof value === "string" && !isAddress(value))
          throw new InvalidAddressError({ address: value });
        const bytesMatch = type.match(bytesRegex2);
        if (bytesMatch) {
          const [_type, size_] = bytesMatch;
          if (size_ && size(value) !== Number.parseInt(size_))
            throw new BytesSizeMismatchError({
              expectedSize: Number.parseInt(size_),
              givenSize: size(value)
            });
        }
        const struct2 = types[type];
        if (struct2) {
          validateReference(type);
          validateData(struct2, value);
        }
      }
    };
    if (types.EIP712Domain && domain)
      validateData(types.EIP712Domain, domain);
    if (primaryType !== "EIP712Domain") {
      if (types[primaryType])
        validateData(types[primaryType], message);
      else
        throw new InvalidPrimaryTypeError({ primaryType, types });
    }
  }
  function getTypesForEIP712Domain({ domain }) {
    return [
      typeof domain?.name === "string" && { name: "name", type: "string" },
      domain?.version && { name: "version", type: "string" },
      typeof domain?.chainId === "number" && {
        name: "chainId",
        type: "uint256"
      },
      domain?.verifyingContract && {
        name: "verifyingContract",
        type: "address"
      },
      domain?.salt && { name: "salt", type: "bytes32" }
    ].filter(Boolean);
  }
  function domainSeparator({ domain }) {
    return hashDomain({
      domain,
      types: {
        EIP712Domain: getTypesForEIP712Domain({ domain })
      }
    });
  }
  function validateReference(type) {
    if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
      throw new InvalidStructTypeError({ type });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
  init_abi();
  init_slice();
  init_toFunctionSelector();
  init_decodeAbiParameters();
  init_formatAbiItem2();
  function decodeFunctionData(parameters) {
    const { abi: abi2, data } = parameters;
    const signature = slice(data, 0, 4);
    const description = abi2.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
    if (!description)
      throw new AbiFunctionSignatureNotFoundError(signature, {
        docsPath: "/docs/contract/decodeFunctionData"
      });
    return {
      functionName: description.name,
      args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeErrorResult.js
  init_abi();
  init_concat();
  init_toFunctionSelector();
  init_encodeAbiParameters();
  init_formatAbiItem2();
  init_getAbiItem();
  var docsPath6 = "/docs/contract/encodeErrorResult";
  function encodeErrorResult(parameters) {
    const { abi: abi2, errorName, args } = parameters;
    let abiItem = abi2[0];
    if (errorName) {
      const item = getAbiItem({ abi: abi2, args, name: errorName });
      if (!item)
        throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath6 });
      abiItem = item;
    }
    if (abiItem.type !== "error")
      throw new AbiErrorNotFoundError(void 0, { docsPath: docsPath6 });
    const definition = formatAbiItem2(abiItem);
    const signature = toFunctionSelector(definition);
    let data = "0x";
    if (args && args.length > 0) {
      if (!abiItem.inputs)
        throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath6 });
      data = encodeAbiParameters(abiItem.inputs, args);
    }
    return concatHex([signature, data]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_encodeFunctionData();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodeFunctionResult.js
  init_abi();
  init_encodeAbiParameters();
  init_getAbiItem();
  var docsPath7 = "/docs/contract/encodeFunctionResult";
  function encodeFunctionResult(parameters) {
    const { abi: abi2, functionName, result } = parameters;
    let abiItem = abi2[0];
    if (functionName) {
      const item = getAbiItem({ abi: abi2, name: functionName });
      if (!item)
        throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath7 });
      abiItem = item;
    }
    if (abiItem.type !== "function")
      throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath7 });
    if (!abiItem.outputs)
      throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath7 });
    let values = Array.isArray(result) ? result : [result];
    if (abiItem.outputs.length === 0 && !values[0])
      values = [];
    return encodeAbiParameters(abiItem.outputs, values);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/encodePacked.js
  init_abi();
  init_address();
  init_isAddress();
  init_concat();
  init_pad();
  init_toHex();
  function encodePacked(types, values) {
    if (types.length !== values.length)
      throw new AbiEncodingLengthMismatchError({
        expectedLength: types.length,
        givenLength: values.length
      });
    const data = [];
    for (let i = 0; i < types.length; i++) {
      const type = types[i];
      const value = values[i];
      data.push(encode(type, value));
    }
    return concatHex(data);
  }
  function encode(type, value, isArray = false) {
    if (type === "address") {
      const address = value;
      if (!isAddress(address))
        throw new InvalidAddressError({ address });
      return pad(address.toLowerCase(), {
        size: isArray ? 32 : null
      });
    }
    if (type === "string")
      return stringToHex(value);
    if (type === "bytes")
      return value;
    if (type === "bool")
      return pad(boolToHex(value), { size: isArray ? 32 : 1 });
    const intMatch = type.match(integerRegex2);
    if (intMatch) {
      const [_type, baseType, bits = "256"] = intMatch;
      const size3 = Number.parseInt(bits) / 8;
      return numberToHex(value, {
        size: isArray ? 32 : size3,
        signed: baseType === "int"
      });
    }
    const bytesMatch = type.match(bytesRegex2);
    if (bytesMatch) {
      const [_type, size3] = bytesMatch;
      if (Number.parseInt(size3) !== (value.length - 2) / 2)
        throw new BytesSizeMismatchError({
          expectedSize: Number.parseInt(size3),
          givenSize: (value.length - 2) / 2
        });
      return pad(value, { dir: "right", size: isArray ? 32 : null });
    }
    const arrayMatch = type.match(arrayRegex);
    if (arrayMatch && Array.isArray(value)) {
      const [_type, childType] = arrayMatch;
      const data = [];
      for (let i = 0; i < value.length; i++) {
        data.push(encode(childType, value[i], true));
      }
      if (data.length === 0)
        return "0x";
      return concatHex(data);
    }
    throw new UnsupportedPackedAbiType(type);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_concat();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/data/isBytes.js
  function isBytes3(value) {
    if (!value)
      return false;
    if (typeof value !== "object")
      return false;
    if (!("BYTES_PER_ELEMENT" in value))
      return false;
    return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/address/getContractAddress.js
  init_pad();
  init_slice();
  init_toBytes();
  init_keccak256();
  init_getAddress();
  function getContractAddress2(opts) {
    if (opts.opcode === "CREATE2")
      return getCreate2Address(opts);
    return getCreateAddress(opts);
  }
  function getCreateAddress(opts) {
    const from = toBytes(getAddress(opts.from));
    let nonce = toBytes(opts.nonce);
    if (nonce[0] === 0)
      nonce = new Uint8Array([]);
    return getAddress(`0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`);
  }
  function getCreate2Address(opts) {
    const from = toBytes(getAddress(opts.from));
    const salt = pad(isBytes3(opts.salt) ? opts.salt : toBytes(opts.salt), {
      size: 32
    });
    const bytecodeHash = (() => {
      if ("bytecodeHash" in opts) {
        if (isBytes3(opts.bytecodeHash))
          return opts.bytecodeHash;
        return toBytes(opts.bytecodeHash);
      }
      return keccak256(opts.bytecode, "bytes");
    })();
    return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
  init_fromHex();
  init_formatter();
  var receiptStatuses = {
    "0x0": "reverted",
    "0x1": "success"
  };
  function formatTransactionReceipt(transactionReceipt) {
    const receipt = {
      ...transactionReceipt,
      blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
      contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
      cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
      effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
      gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
      logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
      to: transactionReceipt.to ? transactionReceipt.to : null,
      transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
      status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
      type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
    };
    if (transactionReceipt.blobGasPrice)
      receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
    if (transactionReceipt.blobGasUsed)
      receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
    return receipt;
  }
  var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/index.js
  init_fromHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/encoding/fromRlp.js
  init_base();
  init_encoding();
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromRlp(value, to = "hex") {
    const bytes2 = (() => {
      if (typeof value === "string") {
        if (value.length > 3 && value.length % 2 !== 0)
          throw new InvalidHexValueError(value);
        return hexToBytes(value);
      }
      return value;
    })();
    const cursor = createCursor(bytes2, {
      recursiveReadLimit: Number.POSITIVE_INFINITY
    });
    const result = fromRlpCursor(cursor, to);
    return result;
  }
  function fromRlpCursor(cursor, to = "hex") {
    if (cursor.bytes.length === 0)
      return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
    const prefix = cursor.readByte();
    if (prefix < 128)
      cursor.decrementPosition(1);
    if (prefix < 192) {
      const length2 = readLength(cursor, prefix, 128);
      const bytes2 = cursor.readBytes(length2);
      return to === "hex" ? bytesToHex(bytes2) : bytes2;
    }
    const length = readLength(cursor, prefix, 192);
    return readList(cursor, length, to);
  }
  function readLength(cursor, prefix, offset) {
    if (offset === 128 && prefix < 128)
      return 1;
    if (prefix <= offset + 55)
      return prefix - offset;
    if (prefix === offset + 55 + 1)
      return cursor.readUint8();
    if (prefix === offset + 55 + 2)
      return cursor.readUint16();
    if (prefix === offset + 55 + 3)
      return cursor.readUint24();
    if (prefix === offset + 55 + 4)
      return cursor.readUint32();
    throw new BaseError2("Invalid RLP prefix");
  }
  function readList(cursor, length, to) {
    const position = cursor.position;
    const value = [];
    while (cursor.position - position < length)
      value.push(fromRlpCursor(cursor, to));
    return value;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionSignature.js
  init_toSignature();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toEventHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/toFunctionHash.js
  init_toSignatureHash();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/isHash.js
  init_isHex();
  init_size();
  function isHash(hash3) {
    return isHex(hash3) && size(hash3) === 32;
  }

  // node_modules/.deno/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
  init_md();
  init_utils2();
  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
  var idxL = [Id];
  var idxR = [Pi];
  for (let i = 0; i < 4; i++)
    for (let j of [idxL, idxR])
      j.push(j[i].map((k) => Rho[k]));
  var shifts = /* @__PURE__ */ [
    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
  ].map((i) => new Uint8Array(i));
  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
  var Kl = /* @__PURE__ */ new Uint32Array([
    0,
    1518500249,
    1859775393,
    2400959708,
    2840853838
  ]);
  var Kr = /* @__PURE__ */ new Uint32Array([
    1352829926,
    1548603684,
    1836072691,
    2053994217,
    0
  ]);
  function f(group, x, y, z) {
    if (group === 0)
      return x ^ y ^ z;
    else if (group === 1)
      return x & y | ~x & z;
    else if (group === 2)
      return (x | ~y) ^ z;
    else if (group === 3)
      return x & z | y & ~z;
    else
      return x ^ (y | ~z);
  }
  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
  var RIPEMD160 = class extends HashMD {
    constructor() {
      super(64, 20, 8, true);
      this.h0 = 1732584193 | 0;
      this.h1 = 4023233417 | 0;
      this.h2 = 2562383102 | 0;
      this.h3 = 271733878 | 0;
      this.h4 = 3285377520 | 0;
    }
    get() {
      const { h0, h1, h2, h3, h4 } = this;
      return [h0, h1, h2, h3, h4];
    }
    set(h0, h1, h2, h3, h4) {
      this.h0 = h0 | 0;
      this.h1 = h1 | 0;
      this.h2 = h2 | 0;
      this.h3 = h3 | 0;
      this.h4 = h4 | 0;
    }
    process(view, offset) {
      for (let i = 0; i < 16; i++, offset += 4)
        R_BUF[i] = view.getUint32(offset, true);
      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
      for (let group = 0; group < 5; group++) {
        const rGroup = 4 - group;
        const hbl = Kl[group], hbr = Kr[group];
        const rl = idxL[group], rr = idxR[group];
        const sl = shiftsL[group], sr = shiftsR[group];
        for (let i = 0; i < 16; i++) {
          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
        }
        for (let i = 0; i < 16; i++) {
          const tr = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
        }
      }
      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
    }
    roundClean() {
      R_BUF.fill(0);
    }
    destroy() {
      this.destroyed = true;
      this.buffer.fill(0);
      this.set(0, 0, 0, 0, 0);
    }
  };
  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/hash/ripemd160.js
  init_isHex();
  init_toBytes();
  init_toHex();
  function ripemd1602(value, to_) {
    const to = to_ || "hex";
    const bytes2 = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
    if (to === "bytes")
      return bytes2;
    return toHex(bytes2);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  init_keccak256();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/strings.js
  var presignMessagePrefix = "Ethereum Signed Message:\n";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
  init_concat();
  init_size();
  init_toHex();
  function toPrefixedMessage(message_) {
    const message = (() => {
      if (typeof message_ === "string")
        return stringToHex(message_);
      if (typeof message_.raw === "string")
        return message_.raw;
      return bytesToHex(message_.raw);
    })();
    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
    return concat([prefix, message]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/hashMessage.js
  function hashMessage(message, to_) {
    return keccak256(toPrefixedMessage(message), to_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
  async function recoverMessageAddress({ message, signature }) {
    return recoverAddress({ hash: hashMessage(message), signature });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
  async function recoverTypedDataAddress(parameters) {
    const { domain, message, primaryType, signature, types } = parameters;
    return recoverAddress({
      hash: hashTypedData({
        domain,
        message,
        primaryType,
        types
      }),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyHash.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyHash({ address, hash: hash3, signature }) {
    return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyMessage.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyMessage({ address, message, signature }) {
    return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/verifyTypedData.js
  init_getAddress();
  init_isAddressEqual();
  async function verifyTypedData(parameters) {
    const { address, domain, message, primaryType, signature, types } = parameters;
    return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
      domain,
      message,
      primaryType,
      signature,
      types
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/bytes.js
  var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
  var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
  init_slice();
  function isErc6492Signature(signature) {
    return sliceHex(signature, -32) === erc6492MagicBytes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
  function parseErc6492Signature(signature) {
    if (!isErc6492Signature(signature))
      return { signature };
    const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
    return { address, data, signature: signature_ };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
  init_encodeAbiParameters();
  init_concat();
  init_toBytes();
  function serializeErc6492Signature(parameters) {
    const { address, data, signature, to = "hex" } = parameters;
    const signature_ = concatHex([
      encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
      erc6492MagicBytes
    ]);
    if (to === "hex")
      return signature_;
    return hexToBytes(signature_);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
  init_transaction();
  init_slice();
  init_fromHex();
  function getSerializedTransactionType(serializedTransaction) {
    const serializedType = sliceHex(serializedTransaction, 0, 1);
    if (serializedType === "0x04")
      return "eip7702";
    if (serializedType === "0x03")
      return "eip4844";
    if (serializedType === "0x02")
      return "eip1559";
    if (serializedType === "0x01")
      return "eip2930";
    if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
      return "legacy";
    throw new InvalidSerializedTransactionTypeError({ serializedType });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/assertTransaction.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_size();
  init_slice();
  init_fromHex();
  function assertTransactionEIP7702(transaction) {
    const { authorizationList } = transaction;
    if (authorizationList) {
      for (const authorization of authorizationList) {
        const { contractAddress, chainId } = authorization;
        if (!isAddress(contractAddress))
          throw new InvalidAddressError({ address: contractAddress });
        if (chainId < 0)
          throw new InvalidChainIdError({ chainId });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP4844(transaction) {
    const { blobVersionedHashes } = transaction;
    if (blobVersionedHashes) {
      if (blobVersionedHashes.length === 0)
        throw new EmptyBlobError();
      for (const hash3 of blobVersionedHashes) {
        const size_ = size(hash3);
        const version3 = hexToNumber(slice(hash3, 0, 1));
        if (size_ !== 32)
          throw new InvalidVersionedHashSizeError({ hash: hash3, size: size_ });
        if (version3 !== versionedHashVersionKzg)
          throw new InvalidVersionedHashVersionError({
            hash: hash3,
            version: version3
          });
      }
    }
    assertTransactionEIP1559(transaction);
  }
  function assertTransactionEIP1559(transaction) {
    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxFeePerGas && maxFeePerGas > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
  }
  function assertTransactionEIP2930(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }
  function assertTransactionLegacy(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (typeof chainId !== "undefined" && chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (maxPriorityFeePerGas || maxFeePerGas)
      throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
    if (gasPrice && gasPrice > maxUint256)
      throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/parseTransaction.js
  init_address();
  init_transaction();
  init_isAddress();
  init_isHex();
  init_pad();
  init_trim();
  init_fromHex();
  function parseTransaction(serializedTransaction) {
    const type = getSerializedTransactionType(serializedTransaction);
    if (type === "eip1559")
      return parseTransactionEIP1559(serializedTransaction);
    if (type === "eip2930")
      return parseTransactionEIP2930(serializedTransaction);
    if (type === "eip4844")
      return parseTransactionEIP4844(serializedTransaction);
    if (type === "eip7702")
      return parseTransactionEIP7702(serializedTransaction);
    return parseTransactionLegacy(serializedTransaction);
  }
  function parseTransactionEIP7702(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
    if (transactionArray.length !== 10 && transactionArray.length !== 13)
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          authorizationList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip7702"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip7702"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (authorizationList.length !== 0 && authorizationList !== "0x")
      transaction.authorizationList = parseAuthorizationList(authorizationList);
    assertTransactionEIP7702(transaction);
    const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP4844(serializedTransaction) {
    const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
    const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
    const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
    const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
    const [blobs, commitments, proofs] = wrapperArray;
    if (!(transactionArray.length === 11 || transactionArray.length === 14))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip4844"
      });
    const transaction = {
      blobVersionedHashes,
      chainId: hexToNumber(chainId),
      type: "eip4844"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
      transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    if (blobs && commitments && proofs)
      transaction.sidecars = toBlobSidecars({
        blobs,
        commitments,
        proofs
      });
    assertTransactionEIP4844(transaction);
    const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP1559(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 9 || transactionArray.length === 12))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          maxPriorityFeePerGas,
          maxFeePerGas,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 9 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip1559"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip1559"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
      transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
    if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
      transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP1559(transaction);
    const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionEIP2930(serializedTransaction) {
    const transactionArray = toTransactionArray(serializedTransaction);
    const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
    if (!(transactionArray.length === 8 || transactionArray.length === 11))
      throw new InvalidSerializedTransactionError({
        attributes: {
          chainId,
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          accessList,
          ...transactionArray.length > 8 ? {
            v,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "eip2930"
      });
    const transaction = {
      chainId: hexToNumber(chainId),
      type: "eip2930"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    if (accessList.length !== 0 && accessList !== "0x")
      transaction.accessList = parseAccessList(accessList);
    assertTransactionEIP2930(transaction);
    const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
    return { ...signature, ...transaction };
  }
  function parseTransactionLegacy(serializedTransaction) {
    const transactionArray = fromRlp(serializedTransaction, "hex");
    const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
    if (!(transactionArray.length === 6 || transactionArray.length === 9))
      throw new InvalidSerializedTransactionError({
        attributes: {
          nonce,
          gasPrice,
          gas,
          to,
          value,
          data,
          ...transactionArray.length > 6 ? {
            v: chainIdOrV_,
            r,
            s
          } : {}
        },
        serializedTransaction,
        type: "legacy"
      });
    const transaction = {
      type: "legacy"
    };
    if (isHex(to) && to !== "0x")
      transaction.to = to;
    if (isHex(gas) && gas !== "0x")
      transaction.gas = hexToBigInt(gas);
    if (isHex(data) && data !== "0x")
      transaction.data = data;
    if (isHex(nonce) && nonce !== "0x")
      transaction.nonce = hexToNumber(nonce);
    if (isHex(value) && value !== "0x")
      transaction.value = hexToBigInt(value);
    if (isHex(gasPrice) && gasPrice !== "0x")
      transaction.gasPrice = hexToBigInt(gasPrice);
    assertTransactionLegacy(transaction);
    if (transactionArray.length === 6)
      return transaction;
    const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
    if (s === "0x" && r === "0x") {
      if (chainIdOrV > 0)
        transaction.chainId = Number(chainIdOrV);
      return transaction;
    }
    const v = chainIdOrV;
    const chainId = Number((v - 35n) / 2n);
    if (chainId > 0)
      transaction.chainId = chainId;
    else if (v !== 27n && v !== 28n)
      throw new InvalidLegacyVError({ v });
    transaction.v = v;
    transaction.s = s;
    transaction.r = r;
    transaction.yParity = v % 2n === 0n ? 1 : 0;
    return transaction;
  }
  function toTransactionArray(serializedTransaction) {
    return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
  }
  function parseAccessList(accessList_) {
    const accessList = [];
    for (let i = 0; i < accessList_.length; i++) {
      const [address, storageKeys] = accessList_[i];
      if (!isAddress(address, { strict: false }))
        throw new InvalidAddressError({ address });
      accessList.push({
        address,
        storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
      });
    }
    return accessList;
  }
  function parseAuthorizationList(serializedAuthorizationList) {
    const authorizationList = [];
    for (let i = 0; i < serializedAuthorizationList.length; i++) {
      const [chainId, contractAddress, nonce, yParity, r, s] = serializedAuthorizationList[i];
      authorizationList.push({
        chainId: hexToNumber(chainId),
        contractAddress,
        nonce: hexToNumber(nonce),
        ...parseEIP155Signature([yParity, r, s])
      });
    }
    return authorizationList;
  }
  function parseEIP155Signature(transactionArray) {
    const signature = transactionArray.slice(-3);
    const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
    return {
      r: padHex(signature[1], { size: 32 }),
      s: padHex(signature[2], { size: 32 }),
      v,
      yParity: v === 27n ? 0 : 1
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  init_transaction();
  init_concat();
  init_trim();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
  init_toHex();
  function serializeAuthorizationList(authorizationList) {
    if (!authorizationList || authorizationList.length === 0)
      return [];
    const serializedAuthorizationList = [];
    for (const authorization of authorizationList) {
      const { contractAddress, chainId, nonce, ...signature } = authorization;
      serializedAuthorizationList.push([
        chainId ? toHex(chainId) : "0x",
        contractAddress,
        nonce ? toHex(nonce) : "0x",
        ...toYParitySignatureArray({}, signature)
      ]);
    }
    return serializedAuthorizationList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
  init_address();
  init_transaction();
  init_isAddress();
  function serializeAccessList(accessList) {
    if (!accessList || accessList.length === 0)
      return [];
    const serializedAccessList = [];
    for (let i = 0; i < accessList.length; i++) {
      const { address, storageKeys } = accessList[i];
      for (let j = 0; j < storageKeys.length; j++) {
        if (storageKeys[j].length - 2 !== 64) {
          throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
        }
      }
      if (!isAddress(address, { strict: false })) {
        throw new InvalidAddressError({ address });
      }
      serializedAccessList.push([address, storageKeys]);
    }
    return serializedAccessList;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
  function serializeTransaction(transaction, signature) {
    const type = getTransactionType(transaction);
    if (type === "eip1559")
      return serializeTransactionEIP1559(transaction, signature);
    if (type === "eip2930")
      return serializeTransactionEIP2930(transaction, signature);
    if (type === "eip4844")
      return serializeTransactionEIP4844(transaction, signature);
    if (type === "eip7702")
      return serializeTransactionEIP7702(transaction, signature);
    return serializeTransactionLegacy(transaction, signature);
  }
  function serializeTransactionEIP7702(transaction, signature) {
    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP7702(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
    return concatHex([
      "0x04",
      toRlp([
        toHex(chainId),
        nonce ? toHex(nonce) : "0x",
        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
        maxFeePerGas ? toHex(maxFeePerGas) : "0x",
        gas ? toHex(gas) : "0x",
        to ?? "0x",
        value ? toHex(value) : "0x",
        data ?? "0x",
        serializedAccessList,
        serializedAuthorizationList,
        ...toYParitySignatureArray(transaction, signature)
      ])
    ]);
  }
  function serializeTransactionEIP4844(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP4844(transaction);
    let blobVersionedHashes = transaction.blobVersionedHashes;
    let sidecars = transaction.sidecars;
    if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
      const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
      const kzg = transaction.kzg;
      const commitments2 = blobsToCommitments({
        blobs: blobs2,
        kzg
      });
      if (typeof blobVersionedHashes === "undefined")
        blobVersionedHashes = commitmentsToVersionedHashes({
          commitments: commitments2
        });
      if (typeof sidecars === "undefined") {
        const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
        sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
      }
    }
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
      blobVersionedHashes ?? [],
      ...toYParitySignatureArray(transaction, signature)
    ];
    const blobs = [];
    const commitments = [];
    const proofs = [];
    if (sidecars)
      for (let i = 0; i < sidecars.length; i++) {
        const { blob, commitment, proof } = sidecars[i];
        blobs.push(blob);
        commitments.push(commitment);
        proofs.push(proof);
      }
    return concatHex([
      "0x03",
      sidecars ? (
        // If sidecars are enabled, envelope turns into a "wrapper":
        toRlp([serializedTransaction, blobs, commitments, proofs])
      ) : (
        // If sidecars are disabled, standard envelope is used:
        toRlp(serializedTransaction)
      )
    ]);
  }
  function serializeTransactionEIP1559(transaction, signature) {
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
    assertTransactionEIP1559(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x02",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionEIP2930(transaction, signature) {
    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
    assertTransactionEIP2930(transaction);
    const serializedAccessList = serializeAccessList(accessList);
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializedAccessList,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x01",
      toRlp(serializedTransaction)
    ]);
  }
  function serializeTransactionLegacy(transaction, signature) {
    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
    assertTransactionLegacy(transaction);
    let serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      gasPrice ? toHex(gasPrice) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x"
    ];
    if (signature) {
      const v = (() => {
        if (signature.v >= 35n) {
          const inferredChainId = (signature.v - 35n) / 2n;
          if (inferredChainId > 0)
            return signature.v;
          return 27n + (signature.v === 35n ? 0n : 1n);
        }
        if (chainId > 0)
          return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
        const v2 = 27n + (signature.v === 27n ? 0n : 1n);
        if (signature.v !== v2)
          throw new InvalidLegacyVError({ v: signature.v });
        return v2;
      })();
      const r = trim(signature.r);
      const s = trim(signature.s);
      serializedTransaction = [
        ...serializedTransaction,
        toHex(v),
        r === "0x00" ? "0x" : r,
        s === "0x00" ? "0x" : s
      ];
    } else if (chainId > 0) {
      serializedTransaction = [
        ...serializedTransaction,
        toHex(chainId),
        "0x",
        "0x"
      ];
    }
    return toRlp(serializedTransaction);
  }
  function toYParitySignatureArray(transaction, signature_) {
    const signature = signature_ ?? transaction;
    const { v, yParity } = signature;
    if (typeof signature.r === "undefined")
      return [];
    if (typeof signature.s === "undefined")
      return [];
    if (typeof v === "undefined" && typeof yParity === "undefined")
      return [];
    const r = trim(signature.r);
    const s = trim(signature.s);
    const yParity_ = (() => {
      if (typeof yParity === "number")
        return yParity ? toHex(1) : "0x";
      if (v === 0n)
        return "0x";
      if (v === 1n)
        return toHex(1);
      return v === 27n ? "0x" : toHex(1);
    })();
    return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/errors/unit.js
  init_base();
  var InvalidDecimalNumberError = class extends BaseError2 {
    constructor({ value }) {
      super(`Number \`${value}\` is not a valid decimal number.`, {
        name: "InvalidDecimalNumberError"
      });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseUnits.js
  function parseUnits(value, decimals) {
    if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
      throw new InvalidDecimalNumberError({ value });
    let [integer, fraction = "0"] = value.split(".");
    const negative = integer.startsWith("-");
    if (negative)
      integer = integer.slice(1);
    fraction = fraction.replace(/(0+)$/, "");
    if (decimals === 0) {
      if (Math.round(Number(`.${fraction}`)) === 1)
        integer = `${BigInt(integer) + 1n}`;
      fraction = "";
    } else if (fraction.length > decimals) {
      const [left, unit, right] = [
        fraction.slice(0, decimals - 1),
        fraction.slice(decimals - 1, decimals),
        fraction.slice(decimals)
      ];
      const rounded = Math.round(Number(`${unit}.${right}`));
      if (rounded > 9)
        fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
      else
        fraction = `${left}${rounded}`;
      if (fraction.length > decimals) {
        fraction = fraction.slice(1);
        integer = `${BigInt(integer) + 1n}`;
      }
      fraction = fraction.slice(0, decimals);
    } else {
      fraction = fraction.padEnd(decimals, "0");
    }
    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseEther.js
  init_unit();
  function parseEther(ether, unit = "wei") {
    return parseUnits(ether, etherUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/unit/parseGwei.js
  init_unit();
  function parseGwei(ether, unit = "wei") {
    return parseUnits(ether, gweiUnits[unit]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/nonceManager.js
  init_lru();
  function createNonceManager(parameters) {
    const { source } = parameters;
    const deltaMap = /* @__PURE__ */ new Map();
    const nonceMap = new LruMap(8192);
    const promiseMap = /* @__PURE__ */ new Map();
    const getKey = ({ address, chainId }) => `${address}.${chainId}`;
    return {
      async consume({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        const promise = this.get({ address, chainId, client });
        this.increment({ address, chainId });
        const nonce = await promise;
        await source.set({ address, chainId }, nonce);
        nonceMap.set(key, nonce);
        return nonce;
      },
      async increment({ address, chainId }) {
        const key = getKey({ address, chainId });
        const delta = deltaMap.get(key) ?? 0;
        deltaMap.set(key, delta + 1);
      },
      async get({ address, chainId, client }) {
        const key = getKey({ address, chainId });
        let promise = promiseMap.get(key);
        if (!promise) {
          promise = (async () => {
            try {
              const nonce = await source.get({ address, chainId, client });
              const previousNonce = nonceMap.get(key) ?? 0;
              if (previousNonce > 0 && nonce <= previousNonce)
                return previousNonce + 1;
              nonceMap.delete(key);
              return nonce;
            } finally {
              this.reset({ address, chainId });
            }
          })();
          promiseMap.set(key, promise);
        }
        const delta = deltaMap.get(key) ?? 0;
        return delta + await promise;
      },
      reset({ address, chainId }) {
        const key = getKey({ address, chainId });
        deltaMap.delete(key);
        promiseMap.delete(key);
      }
    };
  }
  function jsonRpc() {
    return {
      async get(parameters) {
        const { address, client } = parameters;
        return getTransactionCount(client, {
          address,
          blockTag: "pending"
        });
      },
      set() {
      }
    };
  }
  var nonceManager = /* @__PURE__ */ createNonceManager({
    source: jsonRpc()
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/formatters/proof.js
  function formatStorageProof(storageProof) {
    return storageProof.map((proof) => ({
      ...proof,
      value: BigInt(proof.value)
    }));
  }
  function formatProof(proof) {
    return {
      ...proof,
      balance: proof.balance ? BigInt(proof.balance) : void 0,
      nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
      storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getProof.js
  async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
    const blockTag = blockTag_ ?? "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const proof = await client.request({
      method: "eth_getProof",
      params: [address, storageKeys, blockNumberHex || blockTag]
    });
    return formatProof(proof);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getStorageAt.js
  init_toHex();
  async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    const data = await client.request({
      method: "eth_getStorageAt",
      params: [address, slot, blockNumberHex || blockTag]
    });
    return data;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransaction.js
  init_transaction();
  init_toHex();
  async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash3, index: index2 }) {
    const blockTag = blockTag_ || "latest";
    const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
    let transaction = null;
    if (hash3) {
      transaction = await client.request({
        method: "eth_getTransactionByHash",
        params: [hash3]
      }, { dedupe: true });
    } else if (blockHash) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockHashAndIndex",
        params: [blockHash, numberToHex(index2)]
      }, { dedupe: true });
    } else if (blockNumberHex || blockTag) {
      transaction = await client.request({
        method: "eth_getTransactionByBlockNumberAndIndex",
        params: [blockNumberHex || blockTag, numberToHex(index2)]
      }, { dedupe: Boolean(blockNumberHex) });
    }
    if (!transaction)
      throw new TransactionNotFoundError({
        blockHash,
        blockNumber,
        blockTag,
        hash: hash3,
        index: index2
      });
    const format = client.chain?.formatters?.transaction?.format || formatTransaction;
    return format(transaction);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionConfirmations.js
  async function getTransactionConfirmations(client, { hash: hash3, transactionReceipt }) {
    const [blockNumber, transaction] = await Promise.all([
      getAction(client, getBlockNumber, "getBlockNumber")({}),
      hash3 ? getAction(client, getTransaction, "getTransaction")({ hash: hash3 }) : void 0
    ]);
    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
    if (!transactionBlockNumber)
      return 0n;
    return blockNumber - transactionBlockNumber + 1n;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
  init_transaction();
  async function getTransactionReceipt(client, { hash: hash3 }) {
    const receipt = await client.request({
      method: "eth_getTransactionReceipt",
      params: [hash3]
    }, { dedupe: true });
    if (!receipt)
      throw new TransactionReceiptNotFoundError({ hash: hash3 });
    const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
    return format(receipt);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/multicall.js
  init_abis();
  init_abi();
  init_base();
  init_contract();
  init_decodeFunctionResult();
  init_encodeFunctionData();
  init_getChainContractAddress();
  async function multicall(client, parameters) {
    const { allowFailure = true, batchSize: batchSize_, blockNumber, blockTag, multicallAddress: multicallAddress_, stateOverride } = parameters;
    const contracts2 = parameters.contracts;
    const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
    let multicallAddress = multicallAddress_;
    if (!multicallAddress) {
      if (!client.chain)
        throw new Error("client chain not configured. multicallAddress is required.");
      multicallAddress = getChainContractAddress({
        blockNumber,
        chain: client.chain,
        contract: "multicall3"
      });
    }
    const chunkedCalls = [[]];
    let currentChunk = 0;
    let currentChunkSize = 0;
    for (let i = 0; i < contracts2.length; i++) {
      const { abi: abi2, address, args, functionName } = contracts2[i];
      try {
        const callData = encodeFunctionData({ abi: abi2, args, functionName });
        currentChunkSize += (callData.length - 2) / 2;
        if (
          // Check if batching is enabled.
          batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
          currentChunkSize > batchSize && // Check if the current chunk is not already empty.
          chunkedCalls[currentChunk].length > 0
        ) {
          currentChunk++;
          currentChunkSize = (callData.length - 2) / 2;
          chunkedCalls[currentChunk] = [];
        }
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData,
            target: address
          }
        ];
      } catch (err) {
        const error = getContractError(err, {
          abi: abi2,
          address,
          args,
          docsPath: "/docs/contract/multicall",
          functionName
        });
        if (!allowFailure)
          throw error;
        chunkedCalls[currentChunk] = [
          ...chunkedCalls[currentChunk],
          {
            allowFailure: true,
            callData: "0x",
            target: address
          }
        ];
      }
    }
    const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
      abi: multicall3Abi,
      address: multicallAddress,
      args: [calls],
      blockNumber,
      blockTag,
      functionName: "aggregate3",
      stateOverride
    })));
    const results = [];
    for (let i = 0; i < aggregate3Results.length; i++) {
      const result = aggregate3Results[i];
      if (result.status === "rejected") {
        if (!allowFailure)
          throw result.reason;
        for (let j = 0; j < chunkedCalls[i].length; j++) {
          results.push({
            status: "failure",
            error: result.reason,
            result: void 0
          });
        }
        continue;
      }
      const aggregate3Result = result.value;
      for (let j = 0; j < aggregate3Result.length; j++) {
        const { returnData, success } = aggregate3Result[j];
        const { callData } = chunkedCalls[i][j];
        const { abi: abi2, address, functionName, args } = contracts2[results.length];
        try {
          if (callData === "0x")
            throw new AbiDecodingZeroDataError();
          if (!success)
            throw new RawContractError({ data: returnData });
          const result2 = decodeFunctionResult({
            abi: abi2,
            args,
            data: returnData,
            functionName
          });
          results.push(allowFailure ? { result: result2, status: "success" } : result2);
        } catch (err) {
          const error = getContractError(err, {
            abi: abi2,
            address,
            args,
            docsPath: "/docs/contract/multicall",
            functionName
          });
          if (!allowFailure)
            throw error;
          results.push({ error, result: void 0, status: "failure" });
        }
      }
    }
    if (results.length !== contracts2.length)
      throw new BaseError2("multicall results mismatch");
    return results;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_abis();
  init_contracts();
  init_contract();
  init_encodeDeployData();
  init_getAddress();
  init_isAddressEqual();
  init_isHex();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeSignature.js
  init_secp256k1();
  init_fromHex();
  init_toBytes();
  function serializeSignature({ r, s, to = "hex", v, yParity }) {
    const yParity_ = (() => {
      if (yParity === 0 || yParity === 1)
        return yParity;
      if (v && (v === 27n || v === 28n || v >= 35n))
        return v % 2n === 0n ? 1 : 0;
      throw new Error("Invalid `v` or `yParity` value");
    })();
    const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
    if (to === "hex")
      return signature;
    return hexToBytes(signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyHash.js
  init_call();
  async function verifyHash2(client, parameters) {
    const { address, factory, factoryData, hash: hash3, signature, universalSignatureVerifierAddress = client.chain?.contracts?.universalSignatureVerifier?.address, ...rest } = parameters;
    const signatureHex = (() => {
      if (isHex(signature))
        return signature;
      if (typeof signature === "object" && "r" in signature && "s" in signature)
        return serializeSignature(signature);
      return bytesToHex(signature);
    })();
    const wrappedSignature = await (async () => {
      if (!factory && !factoryData)
        return signatureHex;
      if (isErc6492Signature(signatureHex))
        return signatureHex;
      return serializeErc6492Signature({
        address: factory,
        data: factoryData,
        signature: signatureHex
      });
    })();
    try {
      const args = universalSignatureVerifierAddress ? {
        to: universalSignatureVerifierAddress,
        data: encodeFunctionData({
          abi: universalSignatureValidatorAbi,
          functionName: "isValidSig",
          args: [address, hash3, wrappedSignature]
        }),
        ...rest
      } : {
        data: encodeDeployData({
          abi: universalSignatureValidatorAbi,
          args: [address, hash3, wrappedSignature],
          bytecode: universalSignatureValidatorByteCode
        }),
        ...rest
      };
      const { data } = await getAction(client, call, "call")(args);
      return hexToBool(data ?? "0x0");
    } catch (error) {
      try {
        const verified = isAddressEqual(getAddress(address), await recoverAddress({ hash: hash3, signature }));
        if (verified)
          return true;
      } catch {
      }
      if (error instanceof CallExecutionError) {
        return false;
      }
      throw error;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyMessage.js
  async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/verifyTypedData.js
  async function verifyTypedData2(client, parameters) {
    const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
    const hash3 = hashTypedData({ message, primaryType, types, domain });
    return verifyHash2(client, {
      address,
      factory,
      factoryData,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  init_transaction();
  init_withResolvers();
  init_stringify();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlockNumber.js
  init_fromHex();
  init_stringify();
  function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onBlockNumber, onError, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    let prevBlockNumber;
    const pollBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed,
        pollingInterval
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => poll(async () => {
        try {
          const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({ cacheTime: 0 });
          if (prevBlockNumber) {
            if (blockNumber === prevBlockNumber)
              return;
            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
                emit.onBlockNumber(i, prevBlockNumber);
                prevBlockNumber = i;
              }
            }
          }
          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
            emit.onBlockNumber(blockNumber, prevBlockNumber);
            prevBlockNumber = blockNumber;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlockNumber = () => {
      const observerId = stringify([
        "watchBlockNumber",
        client.uid,
        emitOnBegin,
        emitMissed
      ]);
      return observe(observerId, { onBlockNumber, onError }, (emit) => {
        let active = true;
        let unsubscribe = () => active = false;
        (async () => {
          try {
            const transport = (() => {
              if (client.transport.type === "fallback") {
                const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
                if (!transport2)
                  return client.transport;
                return transport2.value;
              }
              return client.transport;
            })();
            const { unsubscribe: unsubscribe_ } = await transport.subscribe({
              params: ["newHeads"],
              onData(data) {
                if (!active)
                  return;
                const blockNumber = hexToBigInt(data.result?.number);
                emit.onBlockNumber(blockNumber, prevBlockNumber);
                prevBlockNumber = blockNumber;
              },
              onError(error) {
                emit.onError?.(error);
              }
            });
            unsubscribe = unsubscribe_;
            if (!active)
              unsubscribe();
          } catch (err) {
            onError?.(err);
          }
        })();
        return () => unsubscribe();
      });
    };
    return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
  async function waitForTransactionReceipt(client, {
    confirmations = 1,
    hash: hash3,
    onReplaced,
    pollingInterval = client.pollingInterval,
    retryCount = 6,
    retryDelay = ({ count }) => ~~(1 << count) * 200,
    // exponential backoff
    timeout = 18e4
  }) {
    const observerId = stringify(["waitForTransactionReceipt", client.uid, hash3]);
    let transaction;
    let replacedTransaction;
    let receipt;
    let retrying = false;
    const { promise, resolve, reject } = withResolvers();
    const timer = timeout ? setTimeout(() => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash3 })), timeout) : void 0;
    const _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
      const _unwatch = getAction(client, watchBlockNumber, "watchBlockNumber")({
        emitMissed: true,
        emitOnBegin: true,
        poll: true,
        pollingInterval,
        async onBlockNumber(blockNumber_) {
          const done = (fn) => {
            clearTimeout(timer);
            _unwatch();
            fn();
            _unobserve();
          };
          let blockNumber = blockNumber_;
          if (retrying)
            return;
          try {
            if (receipt) {
              if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                return;
              done(() => emit.resolve(receipt));
              return;
            }
            if (!transaction) {
              retrying = true;
              await withRetry(async () => {
                transaction = await getAction(client, getTransaction, "getTransaction")({ hash: hash3 });
                if (transaction.blockNumber)
                  blockNumber = transaction.blockNumber;
              }, {
                delay: retryDelay,
                retryCount
              });
              retrying = false;
            }
            receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({ hash: hash3 });
            if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
              return;
            done(() => emit.resolve(receipt));
          } catch (err) {
            if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
              if (!transaction) {
                retrying = false;
                return;
              }
              try {
                replacedTransaction = transaction;
                retrying = true;
                const block = await withRetry(() => getAction(client, getBlock, "getBlock")({
                  blockNumber,
                  includeTransactions: true
                }), {
                  delay: retryDelay,
                  retryCount,
                  shouldRetry: ({ error }) => error instanceof BlockNotFoundError
                });
                retrying = false;
                const replacementTransaction = block.transactions.find(({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce);
                if (!replacementTransaction)
                  return;
                receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
                  hash: replacementTransaction.hash
                });
                if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
                  return;
                let reason = "replaced";
                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
                  reason = "repriced";
                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
                  reason = "cancelled";
                }
                done(() => {
                  emit.onReplaced?.({
                    reason,
                    replacedTransaction,
                    transaction: replacementTransaction,
                    transactionReceipt: receipt
                  });
                  emit.resolve(receipt);
                });
              } catch (err_) {
                done(() => emit.reject(err_));
              }
            } else {
              done(() => emit.reject(err));
            }
          }
        }
      });
    });
    return promise;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchBlocks.js
  init_stringify();
  function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const includeTransactions = includeTransactions_ ?? false;
    let prevBlock;
    const pollBlocks = () => {
      const observerId = stringify([
        "watchBlocks",
        client.uid,
        blockTag,
        emitMissed,
        emitOnBegin,
        includeTransactions,
        pollingInterval
      ]);
      return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
        try {
          const block = await getAction(client, getBlock, "getBlock")({
            blockTag,
            includeTransactions
          });
          if (block.number && prevBlock?.number) {
            if (block.number === prevBlock.number)
              return;
            if (block.number - prevBlock.number > 1 && emitMissed) {
              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
                const block2 = await getAction(client, getBlock, "getBlock")({
                  blockNumber: i,
                  includeTransactions
                });
                emit.onBlock(block2, prevBlock);
                prevBlock = block2;
              }
            }
          }
          if (
            // If no previous block exists, emit.
            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
            // We don't want to emit blocks in the past.
            block.number && block.number > prevBlock.number
          ) {
            emit.onBlock(block, prevBlock);
            prevBlock = block;
          }
        } catch (err) {
          emit.onError?.(err);
        }
      }, {
        emitOnBegin,
        interval: pollingInterval
      }));
    };
    const subscribeBlocks = () => {
      let active = true;
      let emitFetched = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          if (emitOnBegin) {
            getAction(client, getBlock, "getBlock")({
              blockTag,
              includeTransactions
            }).then((block) => {
              if (!active)
                return;
              if (!emitFetched)
                return;
              onBlock(block, void 0);
              emitFetched = false;
            });
          }
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["newHeads"],
            onData(data) {
              if (!active)
                return;
              const format = client.chain?.formatters?.block?.format || formatBlock;
              const block = format(data.result);
              onBlock(block, prevBlock);
              emitFetched = false;
              prevBlock = block;
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollBlocks() : subscribeBlocks();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchEvent.js
  init_stringify();
  init_abi();
  init_rpc();
  function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
    const enablePolling = (() => {
      if (typeof poll_ !== "undefined")
        return poll_;
      if (typeof fromBlock === "bigint")
        return true;
      if (client.transport.type === "webSocket")
        return false;
      if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
        return false;
      return true;
    })();
    const strict = strict_ ?? false;
    const pollEvent = () => {
      const observerId = stringify([
        "watchEvent",
        address,
        args,
        batch,
        client.uid,
        event,
        pollingInterval,
        fromBlock
      ]);
      return observe(observerId, { onLogs, onError }, (emit) => {
        let previousBlockNumber;
        if (fromBlock !== void 0)
          previousBlockNumber = fromBlock - 1n;
        let filter;
        let initialized = false;
        const unwatch = poll(async () => {
          if (!initialized) {
            try {
              filter = await getAction(client, createEventFilter, "createEventFilter")({
                address,
                args,
                event,
                events,
                strict,
                fromBlock
              });
            } catch {
            }
            initialized = true;
            return;
          }
          try {
            let logs;
            if (filter) {
              logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            } else {
              const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
              if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                logs = await getAction(client, getLogs, "getLogs")({
                  address,
                  args,
                  event,
                  events,
                  fromBlock: previousBlockNumber + 1n,
                  toBlock: blockNumber
                });
              } else {
                logs = [];
              }
              previousBlockNumber = blockNumber;
            }
            if (logs.length === 0)
              return;
            if (batch)
              emit.onLogs(logs);
            else
              for (const log of logs)
                emit.onLogs([log]);
          } catch (err) {
            if (filter && err instanceof InvalidInputRpcError)
              initialized = false;
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribeEvent = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const transport = (() => {
            if (client.transport.type === "fallback") {
              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
              if (!transport2)
                return client.transport;
              return transport2.value;
            }
            return client.transport;
          })();
          const events_ = events ?? (event ? [event] : void 0);
          let topics = [];
          if (events_) {
            const encoded = events_.flatMap((event2) => encodeEventTopics({
              abi: [event2],
              eventName: event2.name,
              args
            }));
            topics = [encoded];
            if (event)
              topics = topics[0];
          }
          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
            params: ["logs", { address, topics }],
            onData(data) {
              if (!active)
                return;
              const log = data.result;
              try {
                const { eventName, args: args2 } = decodeEventLog({
                  abi: events_ ?? [],
                  data: log.data,
                  topics: log.topics,
                  strict
                });
                const formatted = formatLog(log, { args: args2, eventName });
                onLogs([formatted]);
              } catch (err) {
                let eventName;
                let isUnnamed;
                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
                  if (strict_)
                    return;
                  eventName = err.abiItem.name;
                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
                }
                const formatted = formatLog(log, {
                  args: isUnnamed ? [] : {},
                  eventName
                });
                onLogs([formatted]);
              }
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollEvent() : subscribeEvent();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/public/watchPendingTransactions.js
  init_stringify();
  function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
    const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
    const pollPendingTransactions = () => {
      const observerId = stringify([
        "watchPendingTransactions",
        client.uid,
        batch,
        pollingInterval
      ]);
      return observe(observerId, { onTransactions, onError }, (emit) => {
        let filter;
        const unwatch = poll(async () => {
          try {
            if (!filter) {
              try {
                filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
                return;
              } catch (err) {
                unwatch();
                throw err;
              }
            }
            const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
            if (hashes.length === 0)
              return;
            if (batch)
              emit.onTransactions(hashes);
            else
              for (const hash3 of hashes)
                emit.onTransactions([hash3]);
          } catch (err) {
            emit.onError?.(err);
          }
        }, {
          emitOnBegin: true,
          interval: pollingInterval
        });
        return async () => {
          if (filter)
            await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
          unwatch();
        };
      });
    };
    const subscribePendingTransactions = () => {
      let active = true;
      let unsubscribe = () => active = false;
      (async () => {
        try {
          const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
            params: ["newPendingTransactions"],
            onData(data) {
              if (!active)
                return;
              const transaction = data.result;
              onTransactions([transaction]);
            },
            onError(error) {
              onError?.(error);
            }
          });
          unsubscribe = unsubscribe_;
          if (!active)
            unsubscribe();
        } catch (err) {
          onError?.(err);
        }
      })();
      return () => unsubscribe();
    };
    return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
  function parseSiweMessage(message) {
    const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
    const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
    const resources = message.split("Resources:")[1]?.split("\n- ").slice(1);
    return {
      ...prefix,
      ...suffix,
      ...chainId ? { chainId: Number(chainId) } : {},
      ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
      ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
      ...notBefore ? { notBefore: new Date(notBefore) } : {},
      ...requestId ? { requestId } : {},
      ...resources ? { resources } : {},
      ...scheme ? { scheme } : {},
      ...statement ? { statement } : {}
    };
  }
  var prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
  var suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/siwe/validateSiweMessage.js
  init_isAddressEqual();
  function validateSiweMessage(parameters) {
    const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
    if (domain && message.domain !== domain)
      return false;
    if (nonce && message.nonce !== nonce)
      return false;
    if (scheme && message.scheme !== scheme)
      return false;
    if (message.expirationTime && time >= message.expirationTime)
      return false;
    if (message.notBefore && time < message.notBefore)
      return false;
    try {
      if (!message.address)
        return false;
      if (address && !isAddressEqual(message.address, address))
        return false;
    } catch {
      return false;
    }
    return true;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/siwe/verifySiweMessage.js
  async function verifySiweMessage(client, parameters) {
    const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
    const parsed = parseSiweMessage(message);
    if (!parsed.address)
      return false;
    const isValid = validateSiweMessage({
      address,
      domain,
      message: parsed,
      nonce,
      scheme,
      time
    });
    if (!isValid)
      return false;
    const hash3 = hashMessage(message);
    return verifyHash2(client, {
      address: parsed.address,
      hash: hash3,
      signature,
      ...callRequest
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/public.js
  function publicActions(client) {
    return {
      call: (args) => call(client, args),
      createBlockFilter: () => createBlockFilter(client),
      createContractEventFilter: (args) => createContractEventFilter(client, args),
      createEventFilter: (args) => createEventFilter(client, args),
      createPendingTransactionFilter: () => createPendingTransactionFilter(client),
      estimateContractGas: (args) => estimateContractGas(client, args),
      estimateGas: (args) => estimateGas(client, args),
      getBalance: (args) => getBalance(client, args),
      getBlobBaseFee: () => getBlobBaseFee(client),
      getBlock: (args) => getBlock(client, args),
      getBlockNumber: (args) => getBlockNumber(client, args),
      getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
      getBytecode: (args) => getCode(client, args),
      getChainId: () => getChainId(client),
      getCode: (args) => getCode(client, args),
      getContractEvents: (args) => getContractEvents(client, args),
      getEip712Domain: (args) => getEip712Domain(client, args),
      getEnsAddress: (args) => getEnsAddress(client, args),
      getEnsAvatar: (args) => getEnsAvatar(client, args),
      getEnsName: (args) => getEnsName(client, args),
      getEnsResolver: (args) => getEnsResolver(client, args),
      getEnsText: (args) => getEnsText(client, args),
      getFeeHistory: (args) => getFeeHistory(client, args),
      estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
      getFilterChanges: (args) => getFilterChanges(client, args),
      getFilterLogs: (args) => getFilterLogs(client, args),
      getGasPrice: () => getGasPrice(client),
      getLogs: (args) => getLogs(client, args),
      getProof: (args) => getProof(client, args),
      estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
      getStorageAt: (args) => getStorageAt(client, args),
      getTransaction: (args) => getTransaction(client, args),
      getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
      getTransactionCount: (args) => getTransactionCount(client, args),
      getTransactionReceipt: (args) => getTransactionReceipt(client, args),
      multicall: (args) => multicall(client, args),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      readContract: (args) => readContract(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      simulateContract: (args) => simulateContract(client, args),
      verifyMessage: (args) => verifyMessage2(client, args),
      verifySiweMessage: (args) => verifySiweMessage(client, args),
      verifyTypedData: (args) => verifyTypedData2(client, args),
      uninstallFilter: (args) => uninstallFilter(client, args),
      waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
      watchBlocks: (args) => watchBlocks(client, args),
      watchBlockNumber: (args) => watchBlockNumber(client, args),
      watchContractEvent: (args) => watchContractEvent(client, args),
      watchEvent: (args) => watchEvent(client, args),
      watchPendingTransactions: (args) => watchPendingTransactions(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createPublicClient.js
  function createPublicClient(parameters) {
    const { key = "public", name = "Public Client" } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "publicClient"
    });
    return client.extend(publicActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dropTransaction.js
  async function dropTransaction(client, { hash: hash3 }) {
    await client.request({
      method: `${client.mode}_dropTransaction`,
      params: [hash3]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/dumpState.js
  async function dumpState(client) {
    return client.request({
      method: `${client.mode}_dumpState`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getAutomine.js
  async function getAutomine(client) {
    if (client.mode === "ganache")
      return await client.request({
        method: "eth_mining"
      });
    return await client.request({
      method: `${client.mode}_getAutomine`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolContent.js
  async function getTxpoolContent(client) {
    return await client.request({
      method: "txpool_content"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
  init_fromHex();
  async function getTxpoolStatus(client) {
    const { pending, queued } = await client.request({
      method: "txpool_status"
    });
    return {
      pending: hexToNumber(pending),
      queued: hexToNumber(queued)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/impersonateAccount.js
  async function impersonateAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_impersonateAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/increaseTime.js
  init_toHex();
  async function increaseTime(client, { seconds }) {
    return await client.request({
      method: "evm_increaseTime",
      params: [numberToHex(seconds)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/inspectTxpool.js
  async function inspectTxpool(client) {
    return await client.request({
      method: "txpool_inspect"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/loadState.js
  async function loadState(client, { state }) {
    await client.request({
      method: `${client.mode}_loadState`,
      params: [state]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/mine.js
  init_toHex();
  async function mine(client, { blocks, interval }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_mine",
        params: [{ blocks: numberToHex(blocks) }]
      });
    else
      await client.request({
        method: `${client.mode}_mine`,
        params: [numberToHex(blocks), numberToHex(interval || 0)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
  async function removeBlockTimestampInterval(client) {
    await client.request({
      method: `${client.mode}_removeBlockTimestampInterval`
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/reset.js
  async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
    await client.request({
      method: `${client.mode}_reset`,
      params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/revert.js
  async function revert(client, { id }) {
    await client.request({
      method: "evm_revert",
      params: [id]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
  init_extract();
  init_transactionRequest();
  async function sendUnsignedTransaction(client, args) {
    const { accessList, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
    const chainFormat = client.chain?.formatters?.transactionRequest?.format;
    const format = chainFormat || formatTransactionRequest;
    const request = format({
      // Pick out extra data that might exist on the chain's transaction request type.
      ...extract(rest, { format: chainFormat }),
      accessList,
      data,
      from,
      gas,
      gasPrice,
      maxFeePerGas,
      maxPriorityFeePerGas,
      nonce,
      to,
      value
    });
    const hash3 = await client.request({
      method: "eth_sendUnsignedTransaction",
      params: [request]
    });
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setAutomine.js
  async function setAutomine(client, enabled) {
    if (client.mode === "ganache") {
      if (enabled)
        await client.request({ method: "miner_start" });
      else
        await client.request({ method: "miner_stop" });
    } else
      await client.request({
        method: "evm_setAutomine",
        params: [enabled]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBalance.js
  init_toHex();
  async function setBalance(client, { address, value }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountBalance",
        params: [address, numberToHex(value)]
      });
    else
      await client.request({
        method: `${client.mode}_setBalance`,
        params: [address, numberToHex(value)]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
  init_toHex();
  async function setBlockGasLimit(client, { gasLimit }) {
    await client.request({
      method: "evm_setBlockGasLimit",
      params: [numberToHex(gasLimit)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
  async function setBlockTimestampInterval(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: `${client.mode}_setBlockTimestampInterval`,
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCode.js
  async function setCode(client, { address, bytecode }) {
    if (client.mode === "ganache")
      await client.request({
        method: "evm_setAccountCode",
        params: [address, bytecode]
      });
    else
      await client.request({
        method: `${client.mode}_setCode`,
        params: [address, bytecode]
      });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setCoinbase.js
  async function setCoinbase(client, { address }) {
    await client.request({
      method: `${client.mode}_setCoinbase`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setIntervalMining.js
  async function setIntervalMining(client, { interval }) {
    const interval_ = (() => {
      if (client.mode === "hardhat")
        return interval * 1e3;
      return interval;
    })();
    await client.request({
      method: "evm_setIntervalMining",
      params: [interval_]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
  async function setLoggingEnabled(client, enabled) {
    await client.request({
      method: `${client.mode}_setLoggingEnabled`,
      params: [enabled]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setMinGasPrice.js
  init_toHex();
  async function setMinGasPrice(client, { gasPrice }) {
    await client.request({
      method: `${client.mode}_setMinGasPrice`,
      params: [numberToHex(gasPrice)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
  init_toHex();
  async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
    await client.request({
      method: `${client.mode}_setNextBlockBaseFeePerGas`,
      params: [numberToHex(baseFeePerGas)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
  init_toHex();
  async function setNextBlockTimestamp(client, { timestamp }) {
    await client.request({
      method: "evm_setNextBlockTimestamp",
      params: [numberToHex(timestamp)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setNonce.js
  init_toHex();
  async function setNonce(client, { address, nonce }) {
    await client.request({
      method: `${client.mode}_setNonce`,
      params: [address, numberToHex(nonce)]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setRpcUrl.js
  async function setRpcUrl(client, jsonRpcUrl) {
    await client.request({
      method: `${client.mode}_setRpcUrl`,
      params: [jsonRpcUrl]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/setStorageAt.js
  init_toHex();
  async function setStorageAt(client, { address, index: index2, value }) {
    await client.request({
      method: `${client.mode}_setStorageAt`,
      params: [
        address,
        typeof index2 === "number" ? numberToHex(index2) : index2,
        value
      ]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/snapshot.js
  async function snapshot(client) {
    return await client.request({
      method: "evm_snapshot"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
  async function stopImpersonatingAccount(client, { address }) {
    await client.request({
      method: `${client.mode}_stopImpersonatingAccount`,
      params: [address]
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/test.js
  function testActions({ mode: mode2 }) {
    return (client_) => {
      const client = client_.extend(() => ({
        mode: mode2
      }));
      return {
        dropTransaction: (args) => dropTransaction(client, args),
        dumpState: () => dumpState(client),
        getAutomine: () => getAutomine(client),
        getTxpoolContent: () => getTxpoolContent(client),
        getTxpoolStatus: () => getTxpoolStatus(client),
        impersonateAccount: (args) => impersonateAccount(client, args),
        increaseTime: (args) => increaseTime(client, args),
        inspectTxpool: () => inspectTxpool(client),
        loadState: (args) => loadState(client, args),
        mine: (args) => mine(client, args),
        removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
        reset: (args) => reset(client, args),
        revert: (args) => revert(client, args),
        sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
        setAutomine: (args) => setAutomine(client, args),
        setBalance: (args) => setBalance(client, args),
        setBlockGasLimit: (args) => setBlockGasLimit(client, args),
        setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
        setCode: (args) => setCode(client, args),
        setCoinbase: (args) => setCoinbase(client, args),
        setIntervalMining: (args) => setIntervalMining(client, args),
        setLoggingEnabled: (args) => setLoggingEnabled(client, args),
        setMinGasPrice: (args) => setMinGasPrice(client, args),
        setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
        setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
        setNonce: (args) => setNonce(client, args),
        setRpcUrl: (args) => setRpcUrl(client, args),
        setStorageAt: (args) => setStorageAt(client, args),
        snapshot: () => snapshot(client),
        stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
      };
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createTestClient.js
  function createTestClient(parameters) {
    const { key = "test", name = "Test Client", mode: mode2 } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      type: "testClient"
    });
    return client.extend((config) => ({
      mode: mode2,
      ...testActions({ mode: mode2 })(config)
    }));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/deployContract.js
  init_encodeDeployData();
  function deployContract(walletClient, parameters) {
    const { abi: abi2, args, bytecode, ...request } = parameters;
    const calldata = encodeDeployData({ abi: abi2, args, bytecode });
    return sendTransaction(walletClient, {
      ...request,
      data: calldata
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getAddresses.js
  init_getAddress();
  async function getAddresses(client) {
    if (client.account?.type === "local")
      return [client.account.address];
    const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
    return addresses.map((address) => checksumAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/getPermissions.js
  async function getPermissions(client) {
    const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
    return permissions;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestAddresses.js
  init_getAddress();
  async function requestAddresses(client) {
    const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
    return addresses.map((address) => getAddress(address));
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/requestPermissions.js
  async function requestPermissions(client, permissions) {
    return client.request({
      method: "wallet_requestPermissions",
      params: [permissions]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signMessage.js
  init_parseAccount();
  init_toHex();
  async function signMessage(client, { account: account_ = client.account, message }) {
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signMessage"
      });
    const account = parseAccount(account_);
    if (account.signMessage)
      return account.signMessage({ message });
    const message_ = (() => {
      if (typeof message === "string")
        return stringToHex(message);
      if (message.raw instanceof Uint8Array)
        return toHex(message.raw);
      return message.raw;
    })();
    return client.request({
      method: "personal_sign",
      params: [message_, account.address]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTransaction.js
  init_parseAccount();
  init_toHex();
  init_transactionRequest();
  init_assertRequest();
  async function signTransaction(client, parameters) {
    const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTransaction"
      });
    const account = parseAccount(account_);
    assertRequest({
      account,
      ...parameters
    });
    const chainId = await getAction(client, getChainId, "getChainId")({});
    if (chain !== null)
      assertCurrentChain({
        currentChainId: chainId,
        chain
      });
    const formatters4 = chain?.formatters || client.chain?.formatters;
    const format = formatters4?.transactionRequest?.format || formatTransactionRequest;
    if (account.signTransaction)
      return account.signTransaction({
        ...transaction,
        chainId
      }, { serializer: client.chain?.serializers?.transaction });
    return await client.request({
      method: "eth_signTransaction",
      params: [
        {
          ...format(transaction),
          chainId: numberToHex(chainId),
          from: account.address
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/signTypedData.js
  init_parseAccount();
  async function signTypedData(client, parameters) {
    const { account: account_ = client.account, domain, message, primaryType } = parameters;
    if (!account_)
      throw new AccountNotFoundError({
        docsPath: "/docs/actions/wallet/signTypedData"
      });
    const account = parseAccount(account_);
    const types = {
      EIP712Domain: getTypesForEIP712Domain({ domain }),
      ...parameters.types
    };
    validateTypedData({ domain, message, primaryType, types });
    if (account.signTypedData)
      return account.signTypedData({ domain, message, primaryType, types });
    const typedData = serializeTypedData({ domain, message, primaryType, types });
    return client.request({
      method: "eth_signTypedData_v4",
      params: [account.address, typedData]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/switchChain.js
  init_toHex();
  async function switchChain(client, { id }) {
    await client.request({
      method: "wallet_switchEthereumChain",
      params: [
        {
          chainId: numberToHex(id)
        }
      ]
    }, { retryCount: 0 });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/actions/wallet/watchAsset.js
  async function watchAsset(client, params) {
    const added = await client.request({
      method: "wallet_watchAsset",
      params
    }, { retryCount: 0 });
    return added;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/decorators/wallet.js
  function walletActions(client) {
    return {
      addChain: (args) => addChain(client, args),
      deployContract: (args) => deployContract(client, args),
      getAddresses: () => getAddresses(client),
      getChainId: () => getChainId(client),
      getPermissions: () => getPermissions(client),
      prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
      requestAddresses: () => requestAddresses(client),
      requestPermissions: (args) => requestPermissions(client, args),
      sendRawTransaction: (args) => sendRawTransaction(client, args),
      sendTransaction: (args) => sendTransaction(client, args),
      signMessage: (args) => signMessage(client, args),
      signTransaction: (args) => signTransaction(client, args),
      signTypedData: (args) => signTypedData(client, args),
      switchChain: (args) => switchChain(client, args),
      watchAsset: (args) => watchAsset(client, args),
      writeContract: (args) => writeContract(client, args)
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/createWalletClient.js
  function createWalletClient(parameters) {
    const { key = "wallet", name = "Wallet Client", transport } = parameters;
    const client = createClient({
      ...parameters,
      key,
      name,
      transport,
      type: "walletClient"
    });
    return client.extend(walletActions);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/clients/transports/webSocket.js
  init_request();
  function webSocket(url, config = {}) {
    const { keepAlive, key = "webSocket", name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
    return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
      const retryCount = config.retryCount ?? retryCount_;
      const timeout = timeout_ ?? config.timeout ?? 1e4;
      const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
      if (!url_)
        throw new UrlRequiredError();
      return createTransport({
        key,
        name,
        async request({ method, params }) {
          const body = { method, params };
          const rpcClient = await getWebSocketRpcClient(url_, {
            keepAlive,
            reconnect
          });
          const { error, result } = await rpcClient.requestAsync({
            body,
            timeout
          });
          if (error)
            throw new RpcRequestError({
              body,
              error,
              url: url_
            });
          return result;
        },
        retryCount,
        retryDelay,
        timeout,
        type: "webSocket"
      }, {
        getSocket() {
          return getSocket(url_);
        },
        getRpcClient() {
          return getWebSocketRpcClient(url_);
        },
        async subscribe({ params, onData, onError }) {
          const rpcClient = await getWebSocketRpcClient(url_);
          const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
            body: {
              method: "eth_subscribe",
              params
            },
            onError(error) {
              reject(error);
              onError?.(error);
              return;
            },
            onResponse(response) {
              if (response.error) {
                reject(response.error);
                onError?.(response.error);
                return;
              }
              if (typeof response.id === "number") {
                resolve(response);
                return;
              }
              if (response.method !== "eth_subscription")
                return;
              onData(response.params);
            }
          }));
          return {
            subscriptionId,
            async unsubscribe() {
              return new Promise((resolve) => rpcClient.request({
                body: {
                  method: "eth_unsubscribe",
                  params: [subscriptionId]
                },
                onResponse: resolve
              }));
            }
          };
        }
      });
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_abis();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/constants/address.js
  var zeroAddress = "0x0000000000000000000000000000000000000000";

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_contracts();
  init_unit();
  init_number();
  init_abi();
  init_base();
  init_contract();
  init_rpc();
  init_chain();
  init_encoding();
  init_node();
  init_request();
  init_address();
  init_transaction();
  init_data();
  init_stateOverride();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/types/eip1193.js
  var ProviderRpcError2 = class extends Error {
    constructor(code, message) {
      super(message);
      Object.defineProperty(this, "code", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      Object.defineProperty(this, "details", {
        enumerable: true,
        configurable: true,
        writable: true,
        value: void 0
      });
      this.code = code;
      this.details = message;
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeAbiParameters();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/abi/decodeDeployData.js
  init_abi();
  init_decodeAbiParameters();
  var docsPath8 = "/docs/contract/decodeDeployData";
  function decodeDeployData(parameters) {
    const { abi: abi2, bytecode, data } = parameters;
    if (data === bytecode)
      return { bytecode };
    const description = abi2.find((x) => "type" in x && x.type === "constructor");
    if (!description)
      throw new AbiConstructorNotFoundError({ docsPath: docsPath8 });
    if (!("inputs" in description))
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    if (!description.inputs || description.inputs.length === 0)
      throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath8 });
    const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
    return { args, bytecode };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_decodeErrorResult();
  init_decodeFunctionResult();
  init_encodeAbiParameters();
  init_encodeDeployData();
  init_encodeFunctionData();
  init_prepareEncodeFunctionData();
  init_transactionRequest();
  init_getAbiItem();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
  init_toBytes();
  init_toHex();
  function compactSignatureToSignature({ r, yParityAndS }) {
    const yParityAndS_bytes = hexToBytes(yParityAndS);
    const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
    const s = yParityAndS_bytes;
    if (yParity === 1)
      s[0] &= 127;
    return { r, s: bytesToHex(s), yParity };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
  init_secp256k1();
  init_toHex();
  function parseCompactSignature(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    return {
      r: numberToHex(r, { size: 32 }),
      yParityAndS: numberToHex(s, { size: 32 })
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/parseSignature.js
  init_secp256k1();
  init_toHex();
  function parseSignature2(signatureHex) {
    const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
    const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
    const [v, yParity] = (() => {
      if (yParityOrV === 0 || yParityOrV === 1)
        return [void 0, yParityOrV];
      if (yParityOrV === 27)
        return [BigInt(yParityOrV), 0];
      if (yParityOrV === 28)
        return [BigInt(yParityOrV), 1];
      throw new Error("Invalid yParityOrV value");
    })();
    if (typeof v !== "undefined")
      return {
        r: numberToHex(r, { size: 32 }),
        s: numberToHex(s, { size: 32 }),
        v,
        yParity
      };
    return {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      yParity
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
  init_keccak256();
  async function recoverTransactionAddress(parameters) {
    const { serializedTransaction, signature: signature_ } = parameters;
    const transaction = parseTransaction(serializedTransaction);
    const signature = signature_ ?? {
      r: transaction.r,
      s: transaction.s,
      v: transaction.v,
      yParity: transaction.yParity
    };
    const serialized = serializeTransaction({
      ...transaction,
      r: void 0,
      s: void 0,
      v: void 0,
      yParity: void 0,
      sidecars: void 0
    });
    return await recoverAddress({
      hash: keccak256(serialized),
      signature
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
  init_toBytes();
  init_toHex();
  function signatureToCompactSignature(signature) {
    const { r, s, v, yParity } = signature;
    const yParity_ = Number(yParity ?? v - 27n);
    let yParityAndS = s;
    if (yParity_ === 1) {
      const bytes2 = hexToBytes(s);
      bytes2[0] |= 128;
      yParityAndS = bytesToHex(bytes2);
    }
    return { r, yParityAndS };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
  init_secp256k1();
  init_fromHex();
  function serializeCompactSignature({ r, yParityAndS }) {
    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_assertRequest();
  init_toBytes();
  init_toHex();
  init_fromBytes();
  init_ccip2();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
  function sidecarsToVersionedHashes(parameters) {
    const { sidecars, version: version3 } = parameters;
    const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
    const hashes = [];
    for (const { commitment } of sidecars) {
      hashes.push(commitmentToVersionedHash({
        commitment,
        to,
        version: version3
      }));
    }
    return hashes;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/blob/fromBlobs.js
  init_cursor2();
  init_toBytes();
  init_toHex();
  function fromBlobs(parameters) {
    const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
    const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
    const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
    const data = createCursor(new Uint8Array(length));
    let active = true;
    for (const blob of blobs) {
      const cursor = createCursor(blob);
      while (active && cursor.position < blob.length) {
        cursor.incrementPosition(1);
        let consume = 31;
        if (blob.length - cursor.position < 31)
          consume = blob.length - cursor.position;
        for (const _ in Array.from({ length: consume })) {
          const byte = cursor.readByte();
          const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
          if (isTerminator) {
            active = false;
            break;
          }
          data.pushByte(byte);
        }
      }
    }
    const trimmedData = data.bytes.slice(0, data.position);
    return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/defineKzg.js
  function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
    return {
      blobToKzgCommitment,
      computeBlobKzgProof
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/utils/kzg/setupKzg.js
  function setupKzg(parameters, path) {
    try {
      parameters.loadTrustedSetup(path);
    } catch (e) {
      const error = e;
      if (!error.message.includes("trusted setup is already loaded"))
        throw error;
    }
    return defineKzg(parameters);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/index.js
  init_concat();
  init_getChainContractAddress();
  init_formatEther();
  init_formatGwei();
  init_formatUnits();
  init_fromHex();
  init_getAddress();
  init_toEventSelector();
  init_toFunctionSelector();
  init_isAddress();
  init_isAddressEqual();
  init_isHex();
  init_keccak256();
  init_pad();
  init_size();
  init_slice();
  init_stringify();
  init_trim();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/index.js
  var chains_exports = {};
  __export(chains_exports, {
    abstractTestnet: () => abstractTestnet,
    acala: () => acala,
    alienx: () => alienx,
    alienxHalTestnet: () => alienxHalTestnet,
    ancient8: () => ancient8,
    ancient8Sepolia: () => ancient8Sepolia,
    anvil: () => anvil,
    apeChain: () => apeChain,
    apexTestnet: () => apexTestnet,
    arbitrum: () => arbitrum,
    arbitrumGoerli: () => arbitrumGoerli,
    arbitrumNova: () => arbitrumNova,
    arbitrumSepolia: () => arbitrumSepolia,
    areonNetwork: () => areonNetwork,
    areonNetworkTestnet: () => areonNetworkTestnet,
    artelaTestnet: () => artelaTestnet,
    assetChain: () => assetChain,
    assetChainTestnet: () => assetChainTestnet,
    astar: () => astar,
    astarZkEVM: () => astarZkEVM,
    astarZkyoto: () => astarZkyoto,
    atletaOlympia: () => atletaOlympia,
    aurora: () => aurora,
    auroraTestnet: () => auroraTestnet,
    auroria: () => auroria,
    avalanche: () => avalanche,
    avalancheFuji: () => avalancheFuji,
    b3: () => b3,
    b3Sepolia: () => b3Sepolia,
    bahamut: () => bahamut,
    base: () => base,
    baseGoerli: () => baseGoerli,
    baseSepolia: () => baseSepolia,
    beam: () => beam,
    beamTestnet: () => beamTestnet,
    bearNetworkChainMainnet: () => bearNetworkChainMainnet,
    bearNetworkChainTestnet: () => bearNetworkChainTestnet,
    berachainTestnet: () => berachainTestnet,
    berachainTestnetbArtio: () => berachainTestnetbArtio,
    bevmMainnet: () => bevmMainnet,
    bifrost: () => bifrost,
    bitTorrent: () => bitTorrent,
    bitTorrentTestnet: () => bitTorrentTestnet,
    bitkub: () => bitkub,
    bitkubTestnet: () => bitkubTestnet,
    bitlayer: () => bitlayer,
    bitlayerTestnet: () => bitlayerTestnet,
    bitrock: () => bitrock,
    blast: () => blast,
    blastSepolia: () => blastSepolia,
    bob: () => bob,
    bobSepolia: () => bobSepolia,
    boba: () => boba,
    bobaSepolia: () => bobaSepolia,
    botanixTestnet: () => botanixTestnet,
    bounceBit: () => bounceBit,
    bounceBitTestnet: () => bounceBitTestnet,
    bronos: () => bronos,
    bronosTestnet: () => bronosTestnet,
    bsc: () => bsc,
    bscGreenfield: () => bscGreenfield,
    bscTestnet: () => bscTestnet,
    bsquared: () => bsquared,
    bsquaredTestnet: () => bsquaredTestnet,
    btr: () => btr,
    btrTestnet: () => btrTestnet,
    bxn: () => bxn,
    bxnTestnet: () => bxnTestnet,
    cannon: () => cannon,
    canto: () => canto,
    celo: () => celo,
    celoAlfajores: () => celoAlfajores,
    chang: () => chang,
    chiliz: () => chiliz,
    chips: () => chips,
    classic: () => classic,
    confluxESpace: () => confluxESpace,
    confluxESpaceTestnet: () => confluxESpaceTestnet,
    coreDao: () => coreDao,
    crab: () => crab,
    cronos: () => cronos,
    cronosTestnet: () => cronosTestnet,
    cronoszkEVM: () => cronoszkEVM,
    cronoszkEVMTestnet: () => cronoszkEVMTestnet,
    crossbell: () => crossbell,
    curtis: () => curtis,
    cyber: () => cyber,
    cyberTestnet: () => cyberTestnet,
    darwinia: () => darwinia,
    dchain: () => dchain,
    dchainTestnet: () => dchainTestnet,
    defichainEvm: () => defichainEvm,
    defichainEvmTestnet: () => defichainEvmTestnet,
    degen: () => degen,
    dfk: () => dfk,
    dodochainTestnet: () => dodochainTestnet,
    dogechain: () => dogechain,
    dosChain: () => dosChain,
    dosChainTestnet: () => dosChainTestnet,
    dreyerxMainnet: () => dreyerxMainnet,
    dreyerxTestnet: () => dreyerxTestnet,
    dustboyIoT: () => dustboyIoT,
    dymension: () => dymension,
    edgeless: () => edgeless,
    edgelessTestnet: () => edgelessTestnet,
    edgeware: () => edgeware,
    edgewareTestnet: () => edgewareTestnet,
    ekta: () => ekta,
    ektaTestnet: () => ektaTestnet,
    elastos: () => elastos,
    elastosTestnet: () => elastosTestnet,
    electroneum: () => electroneum,
    electroneumTestnet: () => electroneumTestnet,
    elysiumTestnet: () => elysiumTestnet,
    eon: () => eon,
    eos: () => eos,
    eosTestnet: () => eosTestnet,
    etherlink: () => etherlink,
    etherlinkTestnet: () => etherlinkTestnet,
    evmos: () => evmos,
    evmosTestnet: () => evmosTestnet,
    excelonMainnet: () => excelonMainnet,
    fantom: () => fantom,
    fantomSonicTestnet: () => fantomSonicTestnet,
    fantomTestnet: () => fantomTestnet,
    fibo: () => fibo,
    filecoin: () => filecoin,
    filecoinCalibration: () => filecoinCalibration,
    filecoinHyperspace: () => filecoinHyperspace,
    flare: () => flare,
    flareTestnet: () => flareTestnet,
    flowMainnet: () => flowMainnet,
    flowPreviewnet: () => flowPreviewnet,
    flowTestnet: () => flowTestnet,
    fluence: () => fluence,
    fluenceStage: () => fluenceStage,
    fluenceTestnet: () => fluenceTestnet,
    forma: () => forma,
    foundry: () => foundry,
    fraxtal: () => fraxtal,
    fraxtalTestnet: () => fraxtalTestnet,
    funkiMainnet: () => funkiMainnet,
    funkiSepolia: () => funkiSepolia,
    fuse: () => fuse,
    fuseSparknet: () => fuseSparknet,
    fusion: () => fusion,
    fusionTestnet: () => fusionTestnet,
    garnet: () => garnet,
    genesys: () => genesys,
    gnosis: () => gnosis,
    gnosisChiado: () => gnosisChiado,
    goChain: () => goChain,
    gobi: () => gobi,
    goerli: () => goerli,
    gravity: () => gravity,
    guruTestnet: () => guruTestnet,
    ham: () => ham,
    haqqMainnet: () => haqqMainnet,
    haqqTestedge2: () => haqqTestedge2,
    hardhat: () => hardhat,
    harmonyOne: () => harmonyOne,
    hashkeyTestnet: () => hashkeyTestnet,
    hedera: () => hedera,
    hederaPreviewnet: () => hederaPreviewnet,
    hederaTestnet: () => hederaTestnet,
    hela: () => hela,
    hemiSepolia: () => hemiSepolia,
    holesky: () => holesky,
    hychain: () => hychain,
    hychainTestnet: () => hychainTestnet,
    immutableZkEvm: () => immutableZkEvm,
    immutableZkEvmTestnet: () => immutableZkEvmTestnet,
    inEVM: () => inEVM,
    iota: () => iota,
    iotaTestnet: () => iotaTestnet,
    iotex: () => iotex,
    iotexTestnet: () => iotexTestnet,
    jbc: () => jbc,
    jbcTestnet: () => jbcTestnet,
    kaia: () => kaia,
    kairos: () => kairos,
    kakarotSepolia: () => kakarotSepolia,
    kakarotStarknetSepolia: () => kakarotStarknetSepolia,
    karura: () => karura,
    kava: () => kava,
    kavaTestnet: () => kavaTestnet,
    kcc: () => kcc,
    kinto: () => kinto,
    klaytn: () => klaytn,
    klaytnBaobab: () => klaytnBaobab,
    koi: () => koi,
    kroma: () => kroma,
    kromaSepolia: () => kromaSepolia,
    l3x: () => l3x,
    l3xTestnet: () => l3xTestnet,
    lavita: () => lavita,
    lightlinkPegasus: () => lightlinkPegasus,
    lightlinkPhoenix: () => lightlinkPhoenix,
    linea: () => linea,
    lineaGoerli: () => lineaGoerli,
    lineaSepolia: () => lineaSepolia,
    lineaTestnet: () => lineaTestnet,
    lisk: () => lisk,
    liskSepolia: () => liskSepolia,
    localhost: () => localhost,
    loop: () => loop,
    lukso: () => lukso,
    luksoTestnet: () => luksoTestnet,
    lycan: () => lycan,
    lyra: () => lyra,
    mainnet: () => mainnet,
    mandala: () => mandala,
    manta: () => manta,
    mantaSepoliaTestnet: () => mantaSepoliaTestnet,
    mantaTestnet: () => mantaTestnet,
    mantle: () => mantle,
    mantleSepoliaTestnet: () => mantleSepoliaTestnet,
    mantleTestnet: () => mantleTestnet,
    mapProtocol: () => mapProtocol,
    matchain: () => matchain,
    matchainTestnet: () => matchainTestnet,
    merlin: () => merlin,
    metachain: () => metachain,
    metachainIstanbul: () => metachainIstanbul,
    metalL2: () => metalL2,
    meter: () => meter,
    meterTestnet: () => meterTestnet,
    metis: () => metis,
    metisGoerli: () => metisGoerli,
    mev: () => mev,
    mevTestnet: () => mevTestnet,
    mint: () => mint,
    mintSepoliaTestnet: () => mintSepoliaTestnet,
    mode: () => mode,
    modeTestnet: () => modeTestnet,
    moonbaseAlpha: () => moonbaseAlpha,
    moonbeam: () => moonbeam,
    moonbeamDev: () => moonbeamDev,
    moonriver: () => moonriver,
    morphHolesky: () => morphHolesky,
    morphSepolia: () => morphSepolia,
    nautilus: () => nautilus,
    neonDevnet: () => neonDevnet,
    neonMainnet: () => neonMainnet,
    nexi: () => nexi,
    nexilix: () => nexilix,
    oasisTestnet: () => oasisTestnet,
    oasys: () => oasys,
    odysseyTestnet: () => odysseyTestnet,
    okc: () => okc,
    oortMainnetDev: () => oortMainnetDev,
    opBNB: () => opBNB,
    opBNBTestnet: () => opBNBTestnet,
    optimism: () => optimism,
    optimismGoerli: () => optimismGoerli,
    optimismSepolia: () => optimismSepolia,
    optopia: () => optopia,
    optopiaTestnet: () => optopiaTestnet,
    orderly: () => orderly,
    orderlySepolia: () => orderlySepolia,
    otimDevnet: () => otimDevnet,
    palm: () => palm,
    palmTestnet: () => palmTestnet,
    pgn: () => pgn,
    pgnTestnet: () => pgnTestnet,
    phoenix: () => phoenix,
    playfiAlbireo: () => playfiAlbireo,
    plinga: () => plinga,
    plumeTestnet: () => plumeTestnet,
    polygon: () => polygon,
    polygonAmoy: () => polygonAmoy,
    polygonMumbai: () => polygonMumbai,
    polygonZkEvm: () => polygonZkEvm,
    polygonZkEvmCardona: () => polygonZkEvmCardona,
    polygonZkEvmTestnet: () => polygonZkEvmTestnet,
    pulsechain: () => pulsechain,
    pulsechainV4: () => pulsechainV4,
    qMainnet: () => qMainnet,
    qTestnet: () => qTestnet,
    ql1: () => ql1,
    real: () => real,
    redbellyTestnet: () => redbellyTestnet,
    redstone: () => redstone,
    reyaNetwork: () => reyaNetwork,
    rollux: () => rollux,
    rolluxTestnet: () => rolluxTestnet,
    ronin: () => ronin,
    root: () => root,
    rootPorcini: () => rootPorcini,
    rootstock: () => rootstock,
    rootstockTestnet: () => rootstockTestnet,
    rss3: () => rss3,
    rss3Sepolia: () => rss3Sepolia,
    saigon: () => saigon,
    sanko: () => sanko,
    sapphire: () => sapphire,
    sapphireTestnet: () => sapphireTestnet,
    satoshiVM: () => satoshiVM,
    satoshiVMTestnet: () => satoshiVMTestnet,
    scroll: () => scroll,
    scrollSepolia: () => scrollSepolia,
    sei: () => sei,
    seiDevnet: () => seiDevnet,
    seiTestnet: () => seiTestnet,
    sepolia: () => sepolia,
    shape: () => shape,
    shapeSepolia: () => shapeSepolia,
    shardeumSphinx: () => shardeumSphinx,
    shibarium: () => shibarium,
    shibariumTestnet: () => shibariumTestnet,
    shiden: () => shiden,
    shimmer: () => shimmer,
    shimmerTestnet: () => shimmerTestnet,
    silicon: () => silicon,
    siliconSepolia: () => siliconSepolia,
    skaleBlockBrawlers: () => skaleBlockBrawlers,
    skaleCalypso: () => skaleCalypso,
    skaleCalypsoTestnet: () => skaleCalypsoTestnet,
    skaleCryptoBlades: () => skaleCryptoBlades,
    skaleCryptoColosseum: () => skaleCryptoColosseum,
    skaleEuropa: () => skaleEuropa,
    skaleEuropaTestnet: () => skaleEuropaTestnet,
    skaleExorde: () => skaleExorde,
    skaleHumanProtocol: () => skaleHumanProtocol,
    skaleNebula: () => skaleNebula,
    skaleNebulaTestnet: () => skaleNebulaTestnet,
    skaleRazor: () => skaleRazor,
    skaleTitan: () => skaleTitan,
    skaleTitanTestnet: () => skaleTitanTestnet,
    sketchpad: () => sketchpad,
    snax: () => snax,
    snaxTestnet: () => snaxTestnet,
    soneiumMinato: () => soneiumMinato,
    songbird: () => songbird,
    songbirdTestnet: () => songbirdTestnet,
    sophonTestnet: () => sophonTestnet,
    spicy: () => spicy,
    step: () => step,
    storyTestnet: () => storyTestnet,
    stratis: () => stratis,
    superlumio: () => superlumio,
    superposition: () => superposition,
    swan: () => swan,
    swanProximaTestnet: () => swanProximaTestnet,
    swanSaturnTestnet: () => swanSaturnTestnet,
    syscoin: () => syscoin,
    syscoinTestnet: () => syscoinTestnet,
    taiko: () => taiko,
    taikoHekla: () => taikoHekla,
    taikoJolnir: () => taikoJolnir,
    taikoKatla: () => taikoKatla,
    taikoTestnetSepolia: () => taikoTestnetSepolia,
    taraxa: () => taraxa,
    taraxaTestnet: () => taraxaTestnet,
    telcoinTestnet: () => telcoinTestnet,
    telos: () => telos,
    telosTestnet: () => telosTestnet,
    tenet: () => tenet,
    thaiChain: () => thaiChain,
    thunderCore: () => thunderCore,
    thunderTestnet: () => thunderTestnet,
    tiktrixTestnet: () => tiktrixTestnet,
    tron: () => tron,
    ultron: () => ultron,
    ultronTestnet: () => ultronTestnet,
    unichainSepolia: () => unichainSepolia,
    unique: () => unique,
    uniqueOpal: () => uniqueOpal,
    uniqueQuartz: () => uniqueQuartz,
    unreal: () => unreal,
    vechain: () => vechain,
    velas: () => velas,
    viction: () => viction,
    victionTestnet: () => victionTestnet,
    vision: () => vision,
    visionTestnet: () => visionTestnet,
    wanchain: () => wanchain,
    wanchainTestnet: () => wanchainTestnet,
    weaveVMAlphanet: () => weaveVMAlphanet,
    wemix: () => wemix,
    wemixTestnet: () => wemixTestnet,
    worldchain: () => worldchain,
    worldchainSepolia: () => worldchainSepolia,
    x1Testnet: () => xLayerTestnet,
    xLayer: () => xLayer,
    xLayerTestnet: () => xLayerTestnet,
    xai: () => xai,
    xaiTestnet: () => xaiTestnet,
    xdc: () => xdc,
    xdcTestnet: () => xdcTestnet,
    xrSepolia: () => xrSepolia,
    yooldoVerse: () => yooldoVerse,
    yooldoVerseTestnet: () => yooldoVerseTestnet,
    zenchainTestnet: () => zenchainTestnet,
    zetachain: () => zetachain,
    zetachainAthensTestnet: () => zetachainAthensTestnet,
    zhejiang: () => zhejiang,
    zilliqa: () => zilliqa,
    zilliqaTestnet: () => zilliqaTestnet,
    zircuit: () => zircuit,
    zircuitTestnet: () => zircuitTestnet,
    zkFair: () => zkFair,
    zkFairTestnet: () => zkFairTestnet,
    zkLinkNova: () => zkLinkNova,
    zkLinkNovaSepoliaTestnet: () => zkLinkNovaSepoliaTestnet,
    zkSync: () => zksync,
    zkSyncInMemoryNode: () => zksyncInMemoryNode,
    zkSyncLocalNode: () => zksyncLocalNode,
    zkSyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zksync: () => zksync,
    zksyncInMemoryNode: () => zksyncInMemoryNode,
    zksyncLocalNode: () => zksyncLocalNode,
    zksyncSepoliaTestnet: () => zksyncSepoliaTestnet,
    zora: () => zora,
    zoraSepolia: () => zoraSepolia,
    zoraTestnet: () => zoraTestnet
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  init_fromHex();
  init_toBytes();
  init_toHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/constants/number.js
  init_number();
  var gasPerPubdataDefault = 50000n;
  var maxBytecodeSize = maxUint16 * 32n;

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/formatters.js
  var formatters = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatters.transaction?.format(transaction);
          if (formatted.typeHex === "0x71")
            formatted.type = "eip712";
          else if (formatted.typeHex === "0xff")
            formatted.type = "priority";
          return formatted;
        });
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTimestamp: args.l1BatchTimestamp ? hexToBigInt(args.l1BatchTimestamp) : null,
          transactions
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x71")
          transaction.type = "eip712";
        else if (args.type === "0xff")
          transaction.type = "priority";
        return {
          ...transaction,
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null
        };
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1BatchNumber: args.l1BatchNumber ? hexToBigInt(args.l1BatchNumber) : null,
          l1BatchTxIndex: args.l1BatchTxIndex ? hexToBigInt(args.l1BatchTxIndex) : null,
          logs: args.logs.map((log) => {
            return {
              ...formatLog(log),
              l1BatchNumber: log.l1BatchNumber ? hexToBigInt(log.l1BatchNumber) : null,
              transactionLogIndex: hexToNumber(log.transactionLogIndex),
              logType: log.logType
            };
          }),
          l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
            return {
              blockNumber: hexToBigInt(l2ToL1Log.blockHash),
              blockHash: l2ToL1Log.blockHash,
              l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
              transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
              shardId: hexToBigInt(l2ToL1Log.shardId),
              isService: l2ToL1Log.isService,
              sender: l2ToL1Log.sender,
              key: l2ToL1Log.key,
              value: l2ToL1Log.value,
              transactionHash: l2ToL1Log.transactionHash,
              logIndex: hexToBigInt(l2ToL1Log.logIndex)
            };
          })
        };
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      exclude: [
        "customSignature",
        "factoryDeps",
        "gasPerPubdata",
        "paymaster",
        "paymasterInput"
      ],
      format(args) {
        if (args.gasPerPubdata || args.paymaster && args.paymasterInput || args.factoryDeps || args.customSignature)
          return {
            eip712Meta: {
              ...args.gasPerPubdata ? { gasPerPubdata: toHex(args.gasPerPubdata) } : { gasPerPubdata: toHex(gasPerPubdataDefault) },
              ...args.paymaster && args.paymasterInput ? {
                paymasterParams: {
                  paymaster: args.paymaster,
                  paymasterInput: Array.from(hexToBytes(args.paymasterInput))
                }
              } : {},
              ...args.factoryDeps ? {
                factoryDeps: args.factoryDeps.map((dep) => Array.from(hexToBytes(dep)))
              } : {},
              ...args.customSignature ? {
                customSignature: Array.from(hexToBytes(args.customSignature))
              } : {}
            },
            type: "0x71"
          };
        return {};
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  init_concat();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  init_address();
  init_base();
  init_chain();
  init_isAddress();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/transaction.js
  init_base();
  var InvalidEip712TransactionError = class extends BaseError2 {
    constructor() {
      super([
        "Transaction is not an EIP712 transaction.",
        "",
        "Transaction must:",
        '  - include `type: "eip712"`',
        "  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`"
      ].join("\n"), { name: "InvalidEip712TransactionError" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/isEip712Transaction.js
  function isEIP712Transaction(transaction) {
    if (transaction.type === "eip712")
      return true;
    if ("customSignature" in transaction && transaction.customSignature || "paymaster" in transaction && transaction.paymaster || "paymasterInput" in transaction && transaction.paymasterInput || "gasPerPubdata" in transaction && typeof transaction.gasPerPubdata === "bigint" || "factoryDeps" in transaction && transaction.factoryDeps)
      return true;
    return false;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
  function assertEip712Transaction(transaction) {
    const { chainId, to, from, paymaster, paymasterInput } = transaction;
    if (!isEIP712Transaction(transaction))
      throw new InvalidEip712TransactionError();
    if (!chainId || chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (paymaster && !isAddress(paymaster))
      throw new InvalidAddressError({ address: paymaster });
    if (paymaster && !paymasterInput) {
      throw new BaseError2("`paymasterInput` must be provided when `paymaster` is defined");
    }
    if (!paymaster && paymasterInput) {
      throw new BaseError2("`paymaster` must be provided when `paymasterInput` is defined");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/serializers.js
  function serializeTransaction2(transaction, signature) {
    if (isEIP712Transaction(transaction))
      return serializeTransactionEIP712(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers = {
    transaction: serializeTransaction2
  };
  function serializeTransactionEIP712(transaction) {
    const { chainId, gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    assertEip712Transaction(transaction);
    const serializedTransaction = [
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x0",
      toHex(chainId),
      toHex(""),
      toHex(""),
      toHex(chainId),
      from ?? "0x",
      gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
      factoryDeps ?? [],
      customSignature ?? "0x",
      // EIP712 signature
      paymaster && paymasterInput ? [paymaster, paymasterInput] : []
    ];
    return concatHex([
      "0x71",
      toRlp(serializedTransaction)
    ]);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  init_pad();
  init_toBytes();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/errors/bytecode.js
  init_base();
  var BytecodeLengthExceedsMaxSizeError = class extends BaseError2 {
    constructor({ givenLength, maxBytecodeSize: maxBytecodeSize2 }) {
      super(`Bytecode cannot be longer than ${maxBytecodeSize2} bytes. Given length: ${givenLength}`, { name: "BytecodeLengthExceedsMaxSizeError" });
    }
  };
  var BytecodeLengthInWordsMustBeOddError = class extends BaseError2 {
    constructor({ givenLengthInWords }) {
      super(`Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`, { name: "BytecodeLengthInWordsMustBeOddError" });
    }
  };
  var BytecodeLengthMustBeDivisibleBy32Error = class extends BaseError2 {
    constructor({ givenLength }) {
      super(`The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`, { name: "BytecodeLengthMustBeDivisibleBy32Error" });
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/hashBytecode.js
  function hashBytecode(bytecode) {
    const bytecodeBytes = toBytes(bytecode);
    if (bytecodeBytes.length % 32 !== 0)
      throw new BytecodeLengthMustBeDivisibleBy32Error({
        givenLength: bytecodeBytes.length
      });
    if (bytecodeBytes.length > maxBytecodeSize)
      throw new BytecodeLengthExceedsMaxSizeError({
        givenLength: bytecodeBytes.length,
        maxBytecodeSize
      });
    const hashStr = sha2562(bytecodeBytes);
    const hash3 = toBytes(hashStr);
    const bytecodeLengthInWords = bytecodeBytes.length / 32;
    if (bytecodeLengthInWords % 2 === 0) {
      throw new BytecodeLengthInWordsMustBeOddError({
        givenLengthInWords: bytecodeLengthInWords
      });
    }
    const bytecodeLength = toBytes(bytecodeLengthInWords);
    const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 });
    const codeHashVersion = new Uint8Array([1, 0]);
    hash3.set(codeHashVersion, 0);
    hash3.set(bytecodeLengthPadded, 2);
    return hash3;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/utils/getEip712Domain.js
  var getEip712Domain2 = (transaction) => {
    assertEip712Transaction(transaction);
    const message = transactionToMessage(transaction);
    return {
      domain: {
        name: "zkSync",
        version: "2",
        chainId: transaction.chainId
      },
      types: {
        Transaction: [
          { name: "txType", type: "uint256" },
          { name: "from", type: "uint256" },
          { name: "to", type: "uint256" },
          { name: "gasLimit", type: "uint256" },
          { name: "gasPerPubdataByteLimit", type: "uint256" },
          { name: "maxFeePerGas", type: "uint256" },
          { name: "maxPriorityFeePerGas", type: "uint256" },
          { name: "paymaster", type: "uint256" },
          { name: "nonce", type: "uint256" },
          { name: "value", type: "uint256" },
          { name: "data", type: "bytes" },
          { name: "factoryDeps", type: "bytes32[]" },
          { name: "paymasterInput", type: "bytes" }
        ]
      },
      primaryType: "Transaction",
      message
    };
  };
  function transactionToMessage(transaction) {
    const { gas, nonce, to, from, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
    return {
      txType: 113n,
      from: BigInt(from),
      to: to ? BigInt(to) : 0n,
      gasLimit: gas ?? 0n,
      gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
      maxFeePerGas: maxFeePerGas ?? 0n,
      maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
      paymaster: paymaster ? BigInt(paymaster) : 0n,
      nonce: nonce ? BigInt(nonce) : 0n,
      value: value ?? 0n,
      data: data ? data : "0x0",
      factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
      paymasterInput: paymasterInput ? paymasterInput : "0x"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/zksync/chainConfig.js
  var chainConfig = {
    formatters,
    serializers,
    custom: {
      getEip712Domain: getEip712Domain2
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/abstractTestnet.js
  var abstractTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 11124,
    name: "Abstract Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.abs.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Abstract Block Explorer",
        url: "https://explorer.testnet.abs.xyz"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
        blockCreated: 358349
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 431682
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/acala.js
  var acala = /* @__PURE__ */ defineChain({
    id: 787,
    name: "Acala",
    network: "acala",
    nativeCurrency: {
      name: "Acala",
      symbol: "ACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-acala.aca-api.network"],
        webSocket: ["wss://eth-rpc-acala.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Acala Blockscout",
        url: "https://blockscout.acala.network",
        apiUrl: "https://blockscout.acala.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienX.js
  var alienx = /* @__PURE__ */ defineChain({
    id: 10241024,
    name: "AlienX Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://explorer.alienxchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/alienXHalTestnet.js
  var alienxHalTestnet = /* @__PURE__ */ defineChain({
    id: 10241025,
    name: "ALIENX Hal Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://hal-rpc.alienxchain.io/http"] }
    },
    blockExplorers: {
      default: {
        name: "AlienX Explorer",
        url: "https://hal-explorer.alienxchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/contracts.js
  var contracts = {
    gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
    l1Block: { address: "0x4200000000000000000000000000000000000015" },
    l2CrossDomainMessenger: {
      address: "0x4200000000000000000000000000000000000007"
    },
    l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
    l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
    l2ToL1MessagePasser: {
      address: "0x4200000000000000000000000000000000000016"
    }
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/formatters.js
  init_fromHex();
  var formatters2 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          if (formatted.typeHex === "0x7e") {
            formatted.isSystemTx = transaction.isSystemTx;
            formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
            formatted.sourceHash = transaction.sourceHash;
            formatted.type = "deposit";
          }
          return formatted;
        });
        return {
          transactions,
          stateRoot: args.stateRoot
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        const transaction = {};
        if (args.type === "0x7e") {
          transaction.isSystemTx = args.isSystemTx;
          transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
          transaction.sourceHash = args.sourceHash;
          transaction.type = "deposit";
        }
        return transaction;
      }
    }),
    transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
      format(args) {
        return {
          l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
          l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
          l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
          l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
        };
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/serializers.js
  init_address();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction3(transaction, signature) {
    if (isDeposit(transaction))
      return serializeTransactionDeposit(transaction);
    return serializeTransaction(transaction, signature);
  }
  var serializers2 = {
    transaction: serializeTransaction3
  };
  function serializeTransactionDeposit(transaction) {
    assertTransactionDeposit(transaction);
    const { sourceHash, data, from, gas, isSystemTx, mint: mint2, to, value } = transaction;
    const serializedTransaction = [
      sourceHash,
      from,
      to ?? "0x",
      mint2 ? toHex(mint2) : "0x",
      value ? toHex(value) : "0x",
      gas ? toHex(gas) : "0x",
      isSystemTx ? "0x1" : "0x",
      data ?? "0x"
    ];
    return concatHex([
      "0x7e",
      toRlp(serializedTransaction)
    ]);
  }
  function isDeposit(transaction) {
    if (transaction.type === "deposit")
      return true;
    if (typeof transaction.sourceHash !== "undefined")
      return true;
    return false;
  }
  function assertTransactionDeposit(transaction) {
    const { from, to } = transaction;
    if (from && !isAddress(from))
      throw new InvalidAddressError({ address: from });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/op-stack/chainConfig.js
  var chainConfig2 = {
    contracts,
    formatters: formatters2,
    serializers: serializers2
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8.js
  var sourceId = 1;
  var ancient8 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 888888888,
    name: "Ancient8",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 explorer",
        url: "https://scan.ancient8.gg",
        apiUrl: "https://scan.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId]: {
          address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
        }
      },
      portal: {
        [sourceId]: {
          address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
          blockCreated: 19070571
        }
      },
      l1StandardBridge: {
        [sourceId]: {
          address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
          blockCreated: 19070571
        }
      }
    },
    sourceId
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ancient8Sepolia.js
  var sourceId2 = 11155111;
  var ancient8Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 28122024,
    name: "Ancient8 Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcv2-testnet.ancient8.gg"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ancient8 Celestia Testnet explorer",
        url: "https://scanv2-testnet.ancient8.gg",
        apiUrl: "https://scanv2-testnet.ancient8.gg/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId2]: {
          address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
        }
      },
      portal: {
        [sourceId2]: {
          address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
          blockCreated: 4972908
        }
      },
      l1StandardBridge: {
        [sourceId2]: {
          address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
          blockCreated: 4972908
        }
      }
    },
    sourceId: sourceId2
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/anvil.js
  var anvil = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Anvil",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apeChain.js
  var sourceId3 = 42161;
  var apeChain = /* @__PURE__ */ defineChain({
    id: 33139,
    name: "Ape Chain",
    nativeCurrency: {
      name: "ApeCoin",
      symbol: "APE",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.apechain.com/http"],
        webSocket: ["wss://rpc.apechain.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Apescan",
        url: "https://apescan.io",
        apiUrl: "https://api.apescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 20889
      }
    },
    sourceId: sourceId3
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/apexTestnet.js
  var apexTestnet = /* @__PURE__ */ defineChain({
    id: 3993,
    name: "APEX Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.apexlayer.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-testnet.apexlayer.xyz",
        apiUrl: "https://exp-testnet.apexlayer.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf7642be33a6b18D16a995657adb5a68CD0438aE2",
        blockCreated: 283775
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrum.js
  var arbitrum = /* @__PURE__ */ defineChain({
    id: 42161,
    name: "Arbitrum One",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://arb1.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://arbiscan.io",
        apiUrl: "https://api.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7654707
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumGoerli.js
  var arbitrumGoerli = /* @__PURE__ */ defineChain({
    id: 421613,
    name: "Arbitrum Goerli",
    nativeCurrency: {
      name: "Arbitrum Goerli Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://goerli-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://goerli.arbiscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 88114
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumNova.js
  var arbitrumNova = /* @__PURE__ */ defineChain({
    id: 42170,
    name: "Arbitrum Nova",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://nova.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://nova.arbiscan.io",
        apiUrl: "https://api-nova.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1746963
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/arbitrumSepolia.js
  var arbitrumSepolia = /* @__PURE__ */ defineChain({
    id: 421614,
    name: "Arbitrum Sepolia",
    nativeCurrency: {
      name: "Arbitrum Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rollup.arbitrum.io/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Arbiscan",
        url: "https://sepolia.arbiscan.io",
        apiUrl: "https://api-sepolia.arbiscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 81930
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetwork.js
  var areonNetwork = /* @__PURE__ */ defineChain({
    id: 463,
    name: "Areon Network",
    nativeCurrency: { decimals: 18, name: "AREA", symbol: "AREA" },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.areon.network"],
        webSocket: ["wss://mainnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 353286
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/areonNetworkTestnet.js
  var areonNetworkTestnet = /* @__PURE__ */ defineChain({
    id: 462,
    name: "Areon Network Testnet",
    nativeCurrency: { decimals: 18, name: "TAREA", symbol: "TAREA" },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.areon.network"],
        webSocket: ["wss://testnet-ws.areon.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Areonscan",
        url: "https://areonscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/artelaTestnet.js
  var artelaTestnet = /* @__PURE__ */ defineChain({
    id: 11822,
    name: "Artela Testnet",
    nativeCurrency: { name: "ART", symbol: "ART", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://betanet-rpc1.artela.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Artela",
        url: "https://betanet-scan.artela.network",
        apiUrl: "https://betanet-scan.artela.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd07c8635f76e8745Ee7092fbb6e8fbc5FeF09DD7",
        blockCreated: 7001871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChain.js
  var assetChain = /* @__PURE__ */ defineChain({
    id: 42420,
    name: "AssetChain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Explorer",
        url: "https://scan.assetchain.org",
        apiUrl: "https://scan.assetchain.org/api"
      }
    },
    testnet: false,
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/assetChainTestnet.js
  var assetChainTestnet = /* @__PURE__ */ defineChain({
    id: 42421,
    name: "AssetChain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Real World Asset",
      symbol: "RWA"
    },
    rpcUrls: {
      default: { http: ["https://enugu-rpc.assetchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Asset Chain Testnet Explorer",
        url: "https://scan-testnet.assetchain.org",
        apiUrl: "https://scan-testnet.assetchain.org/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x989F832D35988cb5e3eB001Fa2Fe789469EC31Ea",
        blockCreated: 17177
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astar.js
  var astar = /* @__PURE__ */ defineChain({
    id: 592,
    name: "Astar",
    network: "astar-mainnet",
    nativeCurrency: {
      name: "Astar",
      symbol: "ASTR",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://astar.api.onfinality.io/public"] }
    },
    blockExplorers: {
      default: {
        name: "Astar Subscan",
        url: "https://astar.subscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 761794
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkEVM.js
  var astarZkEVM = /* @__PURE__ */ defineChain({
    id: 3776,
    name: "Astar zkEVM",
    network: "AstarZkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-zkevm.astar.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Astar zkEVM Explorer",
        url: "https://astar-zkevm.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 93528
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/astarZkyoto.js
  var astarZkyoto = /* @__PURE__ */ defineChain({
    id: 6038361,
    name: "Astar zkEVM Testnet zKyoto",
    network: "zKyoto",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.startale.com/zkyoto"]
      }
    },
    blockExplorers: {
      default: {
        name: "zKyoto Explorer",
        url: "https://zkyoto.explorer.startale.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 196153
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/atletaOlympia.js
  var atletaOlympia = /* @__PURE__ */ defineChain({
    id: 2340,
    name: "Atleta Olympia",
    nativeCurrency: { decimals: 18, name: "Atla", symbol: "ATLA" },
    rpcUrls: {
      default: {
        http: [
          "https://testnet-rpc.atleta.network:9944",
          "https://testnet-rpc.atleta.network"
        ],
        ws: ["wss://testnet-rpc.atleta.network:9944"]
      }
    },
    blockExplorers: {
      default: {
        name: "Atleta Olympia Explorer",
        url: "https://blockscout.atleta.network",
        apiUrl: "https://blockscout.atleta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x1472ec6392180fb84F345d2455bCC75B26577115",
        blockCreated: 1076473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/aurora.js
  var aurora = /* @__PURE__ */ defineChain({
    id: 1313161554,
    name: "Aurora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://aurorascan.dev",
        apiUrl: "https://aurorascan.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 62907816
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroraTestnet.js
  var auroraTestnet = /* @__PURE__ */ defineChain({
    id: 1313161555,
    name: "Aurora Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://testnet.aurora.dev"] }
    },
    blockExplorers: {
      default: {
        name: "Aurorascan",
        url: "https://testnet.aurorascan.dev",
        apiUrl: "https://testnet.aurorascan.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/auroria.js
  var auroria = /* @__PURE__ */ defineChain({
    id: 205205,
    name: "Auroria Testnet",
    network: "auroria",
    nativeCurrency: {
      name: "Auroria Stratis",
      symbol: "tSTRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://auroria.rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Auroria Testnet Explorer",
        url: "https://auroria.explorer.stratisevm.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalanche.js
  var avalanche = /* @__PURE__ */ defineChain({
    id: 43114,
    name: "Avalanche",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://snowtrace.io",
        apiUrl: "https://api.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11907934
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/avalancheFuji.js
  var avalancheFuji = /* @__PURE__ */ defineChain({
    id: 43113,
    name: "Avalanche Fuji",
    nativeCurrency: {
      decimals: 18,
      name: "Avalanche Fuji",
      symbol: "AVAX"
    },
    rpcUrls: {
      default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "SnowTrace",
        url: "https://testnet.snowtrace.io",
        apiUrl: "https://api-testnet.snowtrace.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7096959
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3.js
  var sourceId4 = 8453;
  var b3 = /* @__PURE__ */ defineChain({
    id: 8333,
    name: "B3",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.b3.fun"
      }
    },
    sourceId: sourceId4
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/b3Sepolia.js
  var sourceId5 = 168587773;
  var b3Sepolia = /* @__PURE__ */ defineChain({
    id: 1993,
    name: "B3 Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.b3.fun/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.b3.fun"
      }
    },
    testnet: true,
    sourceId: sourceId5
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bahamut.js
  var bahamut = /* @__PURE__ */ defineChain({
    id: 5165,
    network: "bahamut",
    name: "Bahamut",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc1.bahamut.io",
          "https://bahamut-rpc.publicnode.com",
          "https://rpc2.bahamut.io"
        ],
        webSocket: [
          "wss://ws1.sahara.bahamutchain.com",
          "wss://bahamut-rpc.publicnode.com",
          "wss://ws2.sahara.bahamutchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://www.ftnscan.com",
        apiUrl: "https://www.ftnscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/base.js
  var sourceId6 = 1;
  var base = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 8453,
    name: "Base",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://basescan.org",
        apiUrl: "https://api.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId6]: {
          address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
        }
      },
      l2OutputOracle: {
        [sourceId6]: {
          address: "0x56315b90c40730925ec5485cf004d835058518A0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 5022
      },
      portal: {
        [sourceId6]: {
          address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
          blockCreated: 17482143
        }
      },
      l1StandardBridge: {
        [sourceId6]: {
          address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
          blockCreated: 17482143
        }
      }
    },
    sourceId: sourceId6
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseGoerli.js
  var sourceId7 = 5;
  var baseGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84531,
    name: "Base Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://goerli.base.org"] }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://goerli.basescan.org",
        apiUrl: "https://goerli.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId7]: {
          address: "0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1376988
      },
      portal: {
        [sourceId7]: {
          address: "0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"
        }
      },
      l1StandardBridge: {
        [sourceId7]: {
          address: "0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"
        }
      }
    },
    testnet: true,
    sourceId: sourceId7
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/baseSepolia.js
  var sourceId8 = 11155111;
  var baseSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 84532,
    network: "base-sepolia",
    name: "Base Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.base.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Basescan",
        url: "https://sepolia.basescan.org",
        apiUrl: "https://api-sepolia.basescan.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId8]: {
          address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
        }
      },
      l2OutputOracle: {
        [sourceId8]: {
          address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
        }
      },
      portal: {
        [sourceId8]: {
          address: "0x49f53e41452c74589e85ca1677426ba426459e85",
          blockCreated: 4446677
        }
      },
      l1StandardBridge: {
        [sourceId8]: {
          address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
          blockCreated: 4446677
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1059647
      }
    },
    testnet: true,
    sourceId: sourceId8
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beam.js
  var beam = /* @__PURE__ */ defineChain({
    id: 4337,
    name: "Beam",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc"],
        webSocket: ["wss://build.onbeam.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x4956f15efdc3dc16645e90cc356eafa65ffc65ec",
        blockCreated: 1
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/beamTestnet.js
  var beamTestnet = /* @__PURE__ */ defineChain({
    id: 13337,
    name: "Beam Testnet",
    network: "beam",
    nativeCurrency: {
      decimals: 18,
      name: "Beam",
      symbol: "BEAM"
    },
    rpcUrls: {
      default: {
        http: ["https://build.onbeam.com/rpc/testnet"],
        webSocket: ["wss://build.onbeam.com/ws/testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beam Explorer",
        url: "https://subnets-test.avax.network/beam"
      }
    },
    contracts: {
      multicall3: {
        address: "0x9bf49b704ee2a095b95c1f2d4eb9010510c41c9e",
        blockCreated: 3
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainMainnet.js
  var bearNetworkChainMainnet = /* @__PURE__ */ defineChain({
    id: 641230,
    name: "Bear Network Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "BearNetworkChain",
      symbol: "BRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-mainnet.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkScan",
        url: "https://brnkscan.bearnetwork.net",
        apiUrl: "https://brnkscan.bearnetwork.net/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bearNetworkChainTestnet.js
  var bearNetworkChainTestnet = /* @__PURE__ */ defineChain({
    id: 751230,
    name: "Bear Network Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBRNKC",
      symbol: "tBRNKC"
    },
    rpcUrls: {
      default: { http: ["https://brnkc-test.bearnetwork.net"] }
    },
    blockExplorers: {
      default: {
        name: "BrnkTestScan",
        url: "https://brnktest-scan.bearnetwork.net",
        apiUrl: "https://brnktest-scan.bearnetwork.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnet.js
  var berachainTestnet = /* @__PURE__ */ defineChain({
    id: 80085,
    name: "Berachain Artio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    rpcUrls: {
      default: { http: ["https://artio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain",
        url: "https://artio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/berachainTestnetbArtio.js
  var berachainTestnetbArtio = /* @__PURE__ */ defineChain({
    id: 80084,
    name: "Berachain bArtio",
    nativeCurrency: {
      decimals: 18,
      name: "BERA Token",
      symbol: "BERA"
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 109269
      }
    },
    rpcUrls: {
      default: { http: ["https://bartio.rpc.berachain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Berachain bArtio Beratrail",
        url: "https://bartio.beratrail.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bevmMainnet.js
  var bevmMainnet = /* @__PURE__ */ defineChain({
    id: 11501,
    name: "BEVM Mainnet",
    nativeCurrency: { name: "Bitcoin", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet-1.bevm.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bevmscan",
        url: "https://scan-mainnet.bevm.io",
        apiUrl: "https://scan-mainnet-api.bevm.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bifrost.js
  var bifrost = /* @__PURE__ */ defineChain({
    id: 3068,
    name: "Bifrost Mainnet",
    nativeCurrency: { name: "BFC", symbol: "BFC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://public-01.mainnet.bifrostnetwork.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bifrost Blockscout",
        url: "https://explorer.mainnet.bifrostnetwork.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkub.js
  var bitkub = /* @__PURE__ */ defineChain({
    id: 96,
    name: "Bitkub",
    nativeCurrency: { name: "Bitkub", symbol: "KUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Mainnet Explorer",
        url: "https://www.bkcscan.com",
        apiUrl: "https://www.bkcscan.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitkubTestnet.js
  var bitkubTestnet = /* @__PURE__ */ defineChain({
    id: 25925,
    name: "Bitkub Testnet",
    network: "Bitkub Testnet",
    nativeCurrency: { name: "Bitkub Test", symbol: "tKUB", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.bitkubchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitkub Chain Testnet Explorer",
        url: "https://testnet.bkcscan.com",
        apiUrl: "https://testnet.bkcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayer.js
  var bitlayer = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bitlayer.org"],
        webSocket: ["wss://ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer mainnet scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitlayerTestnet.js
  var bitlayerTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: ["wss://testnet-ws.bitlayer.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "bitlayer testnet scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitrock.js
  var bitrock = /* @__PURE__ */ defineChain({
    id: 7171,
    name: "Bitrock Mainnet",
    nativeCurrency: { name: "BROCK", symbol: "BROCK", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://brockrpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitrock Explorer",
        url: "https://explorer.bit-rock.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrent.js
  var bitTorrent = /* @__PURE__ */ defineChain({
    id: 199,
    name: "BitTorrent",
    network: "bittorrent-chain-mainnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://bttcscan.com",
        apiUrl: "https://api.bttcscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 31078552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bitTorrentTestnet.js
  var bitTorrentTestnet = /* @__PURE__ */ defineChain({
    id: 1028,
    name: "BitTorrent Chain Testnet",
    network: "bittorrent-chain-testnet",
    nativeCurrency: { name: "BitTorrent", symbol: "BTT", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testrpc.bittorrentchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Bttcscan",
        url: "https://testnet.bttcscan.com",
        apiUrl: "https://testnet.bttcscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blast.js
  var sourceId9 = 1;
  var blast = /* @__PURE__ */ defineChain({
    id: 81457,
    name: "Blast",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.blast.io"] }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://blastscan.io",
        apiUrl: "https://api.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 212929
      }
    },
    sourceId: sourceId9
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/blastSepolia.js
  var sourceId10 = 11155111;
  var blastSepolia = /* @__PURE__ */ defineChain({
    id: 168587773,
    name: "Blast Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.blast.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blastscan",
        url: "https://sepolia.blastscan.io",
        apiUrl: "https://api-sepolia.blastscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 756690
      }
    },
    testnet: true,
    sourceId: sourceId10
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bob.js
  var sourceId11 = 1;
  var bob = defineChain({
    ...chainConfig2,
    id: 60808,
    name: "BOB",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gobob.xyz"],
        webSocket: ["wss://rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Explorer",
        url: "https://explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 23131
      },
      l2OutputOracle: {
        [sourceId11]: {
          address: "0xdDa53E23f8a32640b04D7256e651C1db98dB11C1",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId11]: {
          address: "0x8AdeE124447435fE03e3CD24dF3f4cAE32E65a3E",
          blockCreated: 4462615
        }
      }
    },
    sourceId: sourceId11
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/boba.js
  var boba = /* @__PURE__ */ defineChain({
    id: 288,
    name: "Boba Network",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://bobascan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 446859
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobaSepolia.js
  var bobaSepolia = /* @__PURE__ */ defineChain({
    id: 28882,
    name: "Boba Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://sepolia.boba.network"] }
    },
    blockExplorers: {
      default: {
        name: "BOBAScan",
        url: "https://testnet.bobascan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bobSepolia.js
  var sourceId12 = 11155111;
  var bobSepolia = defineChain({
    ...chainConfig2,
    id: 808813,
    name: "BOB Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://bob-sepolia.rpc.gobob.xyz"],
        webSocket: ["wss://bob-sepolia.rpc.gobob.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "BOB Sepolia Explorer",
        url: "https://bob-sepolia.explorer.gobob.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 35677
      },
      l2OutputOracle: {
        [sourceId12]: {
          address: "0x14D0069452b4AE2b250B395b8adAb771E4267d2f",
          blockCreated: 4462615
        }
      },
      portal: {
        [sourceId12]: {
          address: "0x867B1Aa872b9C8cB5E9F7755feDC45BB24Ad0ae4",
          blockCreated: 4462615
        }
      }
    },
    testnet: true,
    sourceId: sourceId12
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/botanixTestnet.js
  var botanixTestnet = /* @__PURE__ */ defineChain({
    id: 3636,
    name: "Botanix Testnet",
    nativeCurrency: { name: "Botanix", symbol: "BTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://poa-node.botanixlabs.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://blockscout.botanixlabs.dev",
        apiUrl: "https://blockscout.botanixlabs.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBit.js
  var bounceBit = /* @__PURE__ */ defineChain({
    id: 6001,
    name: "BounceBit Mainnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-mainnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://bbscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bounceBitTestnet.js
  var bounceBitTestnet = /* @__PURE__ */ defineChain({
    id: 6e3,
    name: "BounceBit Testnet",
    nativeCurrency: { name: "BounceBit", symbol: "BB", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://fullnode-testnet.bouncebitapi.com"] }
    },
    blockExplorers: {
      default: {
        name: "BB Scan",
        url: "https://testnet.bbscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronos.js
  var bronos = /* @__PURE__ */ defineChain({
    id: 1039,
    name: "Bronos",
    nativeCurrency: {
      decimals: 18,
      name: "BRO",
      symbol: "BRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://broscan.bronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bronosTestnet.js
  var bronosTestnet = /* @__PURE__ */ defineChain({
    id: 1038,
    name: "Bronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Bronos Coin",
      symbol: "tBRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-testnet.bronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "BronoScan",
        url: "https://tbroscan.bronos.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsc.js
  var bsc = /* @__PURE__ */ defineChain({
    id: 56,
    name: "BNB Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/bsc"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://bscscan.com",
        apiUrl: "https://api.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15921452
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscGreenfield.js
  var bscGreenfield = /* @__PURE__ */ defineChain({
    id: 1017,
    name: "BNB Greenfield Chain",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "BNB"
    },
    rpcUrls: {
      default: { http: ["https://greenfield-chain.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "BNB Greenfield Mainnet Scan",
        url: "https://greenfieldscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bscTestnet.js
  var bscTestnet = /* @__PURE__ */ defineChain({
    id: 97,
    name: "Binance Smart Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "BNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://data-seed-prebsc-1-s1.bnbchain.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "BscScan",
        url: "https://testnet.bscscan.com",
        apiUrl: "https://api-testnet.bscscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 17422483
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquared.js
  var bsquared = /* @__PURE__ */ defineChain({
    id: 223,
    name: "B2",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.bsquared.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bsquaredTestnet.js
  var bsquaredTestnet = /* @__PURE__ */ defineChain({
    id: 1123,
    name: "B2 Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bsquared.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet-explorer.bsquared.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btr.js
  var btr = /* @__PURE__ */ defineChain({
    id: 200901,
    name: "Bitlayer",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.bitlayer.org",
          "https://rpc.bitlayer-rpc.com",
          "https://rpc.ankr.com/bitlayer"
        ],
        webSocket: ["wss://ws.bitlayer.org", "wss://ws.bitlayer-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://www.btrscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/btrTestnet.js
  var btrTestnet = /* @__PURE__ */ defineChain({
    id: 200810,
    name: "Bitlayer Testnet",
    nativeCurrency: {
      name: "Bitcoin",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.bitlayer.org"],
        webSocket: [
          "wss://testnet-ws.bitlayer.org",
          "wss://testnet-ws.bitlayer-rpc.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Bitlayer(BTR) Scan",
        url: "https://testnet.btrscan.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxn.js
  var bxn = /* @__PURE__ */ defineChain({
    id: 4999,
    name: "BlackFort Exchange Network",
    nativeCurrency: { name: "BlackFort Token", symbol: "BXN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.blackfort.network",
        apiUrl: "https://explorer.blackfort.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/bxnTestnet.js
  var bxnTestnet = /* @__PURE__ */ defineChain({
    id: 4777,
    name: "BlackFort Exchange Network Testnet",
    nativeCurrency: {
      name: "BlackFort Testnet Token",
      symbol: "TBXN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.blackfort.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.blackfort.network",
        apiUrl: "https://testnet-explorer.blackfort.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cannon.js
  var cannon = /* @__PURE__ */ defineChain({
    id: 13370,
    name: "Cannon",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/canto.js
  var canto = /* @__PURE__ */ defineChain({
    id: 7700,
    name: "Canto",
    nativeCurrency: {
      decimals: 18,
      name: "Canto",
      symbol: "CANTO"
    },
    rpcUrls: {
      default: { http: ["https://canto.gravitychain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Tuber.Build (Blockscout)",
        url: "https://tuber.build"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2905789
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/fees.js
  var fees = {
    /*
       * Estimates the fees per gas for a transaction.
    
       * If the transaction is to be paid in a token (feeCurrency is present) then the fees
       * are estimated in the value of the token. Otherwise falls back to the default
       * estimation by returning null.
       *
       * @param params fee estimation function parameters
       */
    estimateFeesPerGas: async (params) => {
      if (!params.request?.feeCurrency)
        return null;
      const [maxFeePerGas, maxPriorityFeePerGas] = await Promise.all([
        estimateFeePerGasInFeeCurrency(params.client, params.request.feeCurrency),
        estimateMaxPriorityFeePerGasInFeeCurrency(params.client, params.request.feeCurrency)
      ]);
      const suggestedMaxFeePerGas = params.multiply(maxFeePerGas) + maxPriorityFeePerGas;
      return {
        maxFeePerGas: suggestedMaxFeePerGas,
        maxPriorityFeePerGas
      };
    }
  };
  async function estimateFeePerGasInFeeCurrency(client, feeCurrency) {
    const fee = await client.request({
      method: "eth_gasPrice",
      params: [feeCurrency]
    });
    return BigInt(fee);
  }
  async function estimateMaxPriorityFeePerGasInFeeCurrency(client, feeCurrency) {
    const feesPerGas = await client.request({
      method: "eth_maxPriorityFeePerGas",
      params: [feeCurrency]
    });
    return BigInt(feesPerGas);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  init_fromHex();
  init_transactionRequest();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/utils.js
  init_trim();
  function isEmpty(value) {
    return value === 0 || value === 0n || value === void 0 || value === null || value === "0" || value === "" || typeof value === "string" && (trim(value).toLowerCase() === "0x" || trim(value).toLowerCase() === "0x00");
  }
  function isPresent(value) {
    return !isEmpty(value);
  }
  function isEIP1559(transaction) {
    return typeof transaction.maxFeePerGas !== "undefined" && typeof transaction.maxPriorityFeePerGas !== "undefined";
  }
  function isCIP64(transaction) {
    if (transaction.type === "cip64") {
      return true;
    }
    return isEIP1559(transaction) && isPresent(transaction.feeCurrency);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/formatters.js
  var formatters3 = {
    block: /* @__PURE__ */ defineBlock({
      format(args) {
        const transactions = args.transactions?.map((transaction) => {
          if (typeof transaction === "string")
            return transaction;
          const formatted = formatTransaction(transaction);
          return {
            ...formatted,
            ...transaction.gatewayFee ? {
              gatewayFee: hexToBigInt(transaction.gatewayFee),
              gatewayFeeRecipient: transaction.gatewayFeeRecipient
            } : {},
            feeCurrency: transaction.feeCurrency
          };
        });
        return {
          transactions,
          ...args.randomness ? { randomness: args.randomness } : {}
        };
      }
    }),
    transaction: /* @__PURE__ */ defineTransaction({
      format(args) {
        if (args.type === "0x7e")
          return {
            isSystemTx: args.isSystemTx,
            mint: args.mint ? hexToBigInt(args.mint) : void 0,
            sourceHash: args.sourceHash,
            type: "deposit"
          };
        const transaction = { feeCurrency: args.feeCurrency };
        if (args.type === "0x7b")
          transaction.type = "cip64";
        else {
          if (args.type === "0x7c")
            transaction.type = "cip42";
          transaction.gatewayFee = args.gatewayFee ? hexToBigInt(args.gatewayFee) : null;
          transaction.gatewayFeeRecipient = args.gatewayFeeRecipient;
        }
        return transaction;
      }
    }),
    transactionRequest: /* @__PURE__ */ defineTransactionRequest({
      format(args) {
        const request = {};
        if (args.feeCurrency)
          request.feeCurrency = args.feeCurrency;
        if (isCIP64(args))
          request.type = "0x7b";
        return request;
      }
    })
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/serializers.js
  init_number();
  init_address();
  init_base();
  init_chain();
  init_node();
  init_isAddress();
  init_concat();
  init_toHex();
  function serializeTransaction4(transaction, signature) {
    if (isCIP64(transaction))
      return serializeTransactionCIP64(transaction, signature);
    return serializeTransaction3(transaction, signature);
  }
  var serializers3 = {
    transaction: serializeTransaction4
  };
  function serializeTransactionCIP64(transaction, signature) {
    assertTransactionCIP64(transaction);
    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, feeCurrency, data } = transaction;
    const serializedTransaction = [
      toHex(chainId),
      nonce ? toHex(nonce) : "0x",
      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
      gas ? toHex(gas) : "0x",
      to ?? "0x",
      value ? toHex(value) : "0x",
      data ?? "0x",
      serializeAccessList(accessList),
      feeCurrency,
      ...toYParitySignatureArray(transaction, signature)
    ];
    return concatHex([
      "0x7b",
      toRlp(serializedTransaction)
    ]);
  }
  var MAX_MAX_FEE_PER_GAS = maxUint256;
  function assertTransactionCIP64(transaction) {
    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, feeCurrency } = transaction;
    if (chainId <= 0)
      throw new InvalidChainIdError({ chainId });
    if (to && !isAddress(to))
      throw new InvalidAddressError({ address: to });
    if (gasPrice)
      throw new BaseError2("`gasPrice` is not a valid CIP-64 Transaction attribute.");
    if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
      throw new FeeCapTooHighError({ maxFeePerGas });
    if (isPresent(maxPriorityFeePerGas) && isPresent(maxFeePerGas) && maxPriorityFeePerGas > maxFeePerGas)
      throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
    if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
      throw new BaseError2("`feeCurrency` MUST be a token address for CIP-64 transactions.");
    }
    if (isEmpty(feeCurrency)) {
      throw new BaseError2("`feeCurrency` must be provided for CIP-64 transactions.");
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/celo/chainConfig.js
  var chainConfig3 = {
    contracts,
    formatters: formatters3,
    serializers: serializers3,
    fees
  };

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celo.js
  var celo = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 42220,
    name: "Celo",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "CELO"
    },
    rpcUrls: {
      default: { http: ["https://forno.celo.org"] }
    },
    blockExplorers: {
      default: {
        name: "Celo Explorer",
        url: "https://celoscan.io",
        apiUrl: "https://api.celoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 13112599
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/celoAlfajores.js
  var sourceId13 = 17e3;
  var celoAlfajores = /* @__PURE__ */ defineChain({
    ...chainConfig3,
    id: 44787,
    name: "Alfajores",
    nativeCurrency: {
      decimals: 18,
      name: "CELO",
      symbol: "A-CELO"
    },
    rpcUrls: {
      default: {
        http: ["https://alfajores-forno.celo-testnet.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Celo Alfajores Explorer",
        url: "https://celo-alfajores.blockscout.com",
        apiUrl: "https://celo-alfajores.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig3.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 14569001
      },
      portal: {
        [sourceId13]: {
          address: "0x82527353927d8D069b3B452904c942dA149BA381",
          blockCreated: 2411324
        }
      },
      disputeGameFactory: {
        [sourceId13]: {
          address: "0xE28AAdcd9883746c0e5068F58f9ea06027b214cb",
          blockCreated: 2411324
        }
      },
      l2OutputOracle: {
        [sourceId13]: {
          address: "0x4a2635e9e4f6e45817b1D402ac4904c1d1752438",
          blockCreated: 2411324
        }
      },
      l1StandardBridge: {
        [sourceId13]: {
          address: "0xD1B0E0581973c9eB7f886967A606b9441A897037",
          blockCreated: 2411324
        }
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chang.js
  var chang = /* @__PURE__ */ defineChain({
    id: 5858,
    name: "Chang Chain Foundation Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "CTH",
      symbol: "CTH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.cthscan.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chang Chain explorer",
        url: "https://cthscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chiliz.js
  var chiliz = /* @__PURE__ */ defineChain({
    id: 88888,
    name: "Chiliz Chain",
    network: "chiliz-chain",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.ankr.com/chiliz",
          "https://chiliz-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "https://scan.chiliz.com",
        apiUrl: "https://scan.chiliz.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/chips.js
  var chips = /* @__PURE__ */ defineChain({
    id: 2882,
    name: "Chips Network",
    network: "CHIPS",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: [
          "https://node.chips.ooo/wasp/api/v1/chains/iota1pp3d3mnap3ufmgqnjsnw344sqmf5svjh26y2khnmc89sv6788y3r207a8fn/evm"
        ]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/classic.js
  var classic = /* @__PURE__ */ defineChain({
    id: 61,
    name: "Ethereum Classic",
    nativeCurrency: {
      decimals: 18,
      name: "ETC",
      symbol: "ETC"
    },
    rpcUrls: {
      default: { http: ["https://etc.rivet.link"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.com/etc/mainnet"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpace.js
  var confluxESpace = /* @__PURE__ */ defineChain({
    id: 1030,
    name: "Conflux eSpace",
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm.confluxrpc.com"],
        webSocket: ["wss://evm.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evm.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 68602935
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/confluxESpaceTestnet.js
  var confluxESpaceTestnet = /* @__PURE__ */ defineChain({
    id: 71,
    name: "Conflux eSpace Testnet",
    network: "cfx-espace-testnet",
    testnet: true,
    nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmtestnet.confluxrpc.com"],
        webSocket: ["wss://evmtestnet.confluxrpc.com/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "ConfluxScan",
        url: "https://evmtestnet.confluxscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xEFf0078910f638cd81996cc117bccD3eDf2B072F",
        blockCreated: 117499050
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/coreDao.js
  var coreDao = /* @__PURE__ */ defineChain({
    id: 1116,
    name: "Core Dao",
    nativeCurrency: {
      decimals: 18,
      name: "Core",
      symbol: "CORE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.coredao.org"] }
    },
    blockExplorers: {
      default: {
        name: "CoreDao",
        url: "https://scan.coredao.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 11907934
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crab.js
  var crab = defineChain({
    id: 44,
    name: "Crab Network",
    nativeCurrency: {
      decimals: 18,
      name: "Crab Network Native Token",
      symbol: "CRAB"
    },
    rpcUrls: {
      default: {
        http: ["https://crab-rpc.darwinia.network"],
        webSocket: ["wss://crab-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://crab-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3032593
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronos.js
  var cronos = /* @__PURE__ */ defineChain({
    id: 25,
    name: "Cronos Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos",
      symbol: "CRO"
    },
    rpcUrls: {
      default: { http: ["https://evm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://explorer.cronos.org",
        apiUrl: "https://explorer-api.cronos.org/mainnet/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1963112
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronosTestnet.js
  var cronosTestnet = /* @__PURE__ */ defineChain({
    id: 338,
    name: "Cronos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CRO",
      symbol: "tCRO"
    },
    rpcUrls: {
      default: { http: ["https://evm-t3.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos Explorer",
        url: "https://cronos.org/explorer/testnet3"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 10191251
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVM.js
  var cronoszkEVM = /* @__PURE__ */ defineChain({
    id: 388,
    name: "Cronos zkEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM CRO",
      symbol: "zkCRO"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM (Mainnet) Chain Explorer",
        url: "https://explorer.zkevm.cronos.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cronoszkEVMTestnet.js
  var cronoszkEVMTestnet = /* @__PURE__ */ defineChain({
    id: 282,
    name: "Cronos zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Cronos zkEVM Test Coin",
      symbol: "zkTCRO"
    },
    rpcUrls: {
      default: { http: ["https://testnet.zkevm.cronos.org"] }
    },
    blockExplorers: {
      default: {
        name: "Cronos zkEVM Testnet Explorer",
        url: "https://explorer.zkevm.cronos.org/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/crossbell.js
  var crossbell = /* @__PURE__ */ defineChain({
    id: 3737,
    name: "Crossbell",
    nativeCurrency: {
      decimals: 18,
      name: "CSB",
      symbol: "CSB"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.crossbell.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "CrossScan",
        url: "https://scan.crossbell.io",
        apiUrl: "https://scan.crossbell.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 38246031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/curtis.js
  var curtis = /* @__PURE__ */ defineChain({
    id: 33111,
    name: "Curtis",
    nativeCurrency: { name: "ApeCoin", symbol: "APE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.curtis.apechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Curtis Explorer",
        url: "https://explorer.curtis.apechain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyber.js
  var cyber = /* @__PURE__ */ defineChain({
    id: 7560,
    name: "Cyber",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://cyberscan.co",
        apiUrl: "https://cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/cyberTestnet.js
  var cyberTestnet = /* @__PURE__ */ defineChain({
    id: 111557560,
    name: "Cyber Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cyber-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet.cyberscan.co",
        apiUrl: "https://testnet.cyberscan.co/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xffc391F0018269d4758AEA1a144772E8FB99545E",
        blockCreated: 304545
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/darwinia.js
  var darwinia = /* @__PURE__ */ defineChain({
    id: 46,
    name: "Darwinia Network",
    nativeCurrency: {
      decimals: 18,
      name: "RING",
      symbol: "RING"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.darwinia.network"],
        webSocket: ["wss://rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Explorer", url: "https://explorer.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69420
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchain.js
  var dchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2716446429837e3,
    name: "Dchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dchain-2716446429837000-1.jsonrpc.sagarpc.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchain-2716446429837000-1.sagaexplorer.io",
        apiUrl: "https://api-dchain-2716446429837000-1.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dchainTestnet.js
  var dchainTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2713017997578e3,
    name: "Dchain Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://dchaintestnet-2713017997578000-1.jsonrpc.testnet.sagarpc.io"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Dchain Explorer",
        url: "https://dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io",
        apiUrl: "https://api-dchaintestnet-2713017997578000-1.testnet.sagaexplorer.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvm.js
  var defichainEvm = /* @__PURE__ */ defineChain({
    id: 1130,
    network: "defichain-evm",
    name: "DeFiChain EVM Mainnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.mainnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 137852
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/defichainEvmTestnet.js
  var defichainEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1131,
    network: "defichain-evm-testnet",
    name: "DeFiChain EVM Testnet",
    nativeCurrency: {
      name: "DeFiChain",
      symbol: "DFI",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth.testnet.ocean.jellyfishsdk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DeFiScan",
        url: "https://meta.defiscan.live/?network=TestNet"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 156462
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/degen.js
  var degen = /* @__PURE__ */ defineChain({
    id: 666666666,
    name: "Degen",
    nativeCurrency: {
      decimals: 18,
      name: "Degen",
      symbol: "DEGEN"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.degen.tips"],
        webSocket: ["wss://rpc.degen.tips"]
      }
    },
    blockExplorers: {
      default: {
        name: "Degen Chain Explorer",
        url: "https://explorer.degen.tips",
        apiUrl: "https://explorer.degen.tips/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dfk.js
  var dfk = /* @__PURE__ */ defineChain({
    id: 53935,
    name: "DFK Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Jewel",
      symbol: "JEWEL"
    },
    rpcUrls: {
      default: {
        http: ["https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "DFKSubnetScan",
        url: "https://subnets.avax.network/defi-kingdoms"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14790551
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dodochainTestnet.js
  var dodochainTestnet = defineChain({
    id: 53457,
    name: "DODOchain Testnet",
    nativeCurrency: { decimals: 18, name: "DODO", symbol: "DODO" },
    rpcUrls: {
      default: {
        http: ["https://dodochain-testnet.alt.technology"],
        webSocket: ["wss://dodochain-testnet.alt.technology/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "DODOchain Testnet (Sepolia) Explorer",
        url: "https://testnet-scan.dodochain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dogechain.js
  var dogechain = /* @__PURE__ */ defineChain({
    id: 2e3,
    name: "Dogechain",
    nativeCurrency: {
      decimals: 18,
      name: "Wrapped Dogecoin",
      symbol: "WDOGE"
    },
    rpcUrls: {
      default: { http: ["https://rpc.dogechain.dog"] }
    },
    blockExplorers: {
      default: {
        name: "DogeChainExplorer",
        url: "https://explorer.dogechain.dog",
        apiUrl: "https://explorer.dogechain.dog/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x68a8609a60a008EFA633dfdec592c03B030cC508",
        blockCreated: 25384031
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChain.js
  var dosChain = /* @__PURE__ */ defineChain({
    id: 7979,
    name: "DOS Chain",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://main.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Explorer",
        url: "https://doscan.io",
        apiUrl: "https://api.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 161908
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dosChainTestnet.js
  var dosChainTestnet = /* @__PURE__ */ defineChain({
    id: 3939,
    name: "DOS Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "DOS Chain Testnet",
      symbol: "DOS"
    },
    rpcUrls: {
      default: { http: ["https://test.doschain.com"] }
    },
    blockExplorers: {
      default: {
        name: "DOS Chain Testnet Explorer",
        url: "https://test.doscan.io",
        apiUrl: "https://api-test.doscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 69623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxMainnet.js
  var dreyerxMainnet = /* @__PURE__ */ defineChain({
    id: 23451,
    name: "DreyerX Mainnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Scan",
        url: "https://scan.dreyerx.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dreyerxTestnet.js
  var dreyerxTestnet = /* @__PURE__ */ defineChain({
    id: 23452,
    name: "DreyerX Testnet",
    nativeCurrency: {
      name: "DreyerX",
      symbol: "DRX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["http://testnet-rpc.dreyerx.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "DreyerX Testnet Scan",
        url: "https://testnet-scan.dreyerx.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dustboyIoT.js
  var dustboyIoT = /* @__PURE__ */ defineChain({
    id: 555888,
    name: "DustBoy IoT",
    nativeCurrency: { name: "Ether", symbol: "DST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dustboy-rpc.jibl2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://dustboy.jibl2.com",
        apiUrl: "https://dustboy.jibl2.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xFFD34aa2C62B2D52E00A361e466C229788f4eD6a",
        blockCreated: 526569
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/dymension.js
  var dymension = /* @__PURE__ */ defineChain({
    id: 1100,
    name: "Dymension",
    nativeCurrency: {
      name: "DYM",
      symbol: "DYM",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://dymension-evm-rpc.publicnode.com"],
        webSocket: ["wss://dymension-evm-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Dym FYI",
        url: "https://dym.fyi"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeless.js
  var edgeless = /* @__PURE__ */ defineChain({
    id: 2026,
    name: "Edgeless Network",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.edgeless.network/http"],
        webSocket: ["wss://rpc.edgeless.network/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Explorer",
        url: "https://explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgelessTestnet.js
  var edgelessTestnet = /* @__PURE__ */ defineChain({
    id: 202,
    name: "Edgeless Testnet",
    nativeCurrency: {
      name: "Edgeless Wrapped ETH",
      symbol: "EwETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://edgeless-testnet.rpc.caldera.xyz/http"],
        webSocket: ["wss://edgeless-testnet.rpc.caldera.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Edgeless Testnet Explorer",
        url: "https://testnet.explorer.edgeless.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgeware.js
  var edgeware = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Edgeware EdgeEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Edgeware",
      symbol: "EDG"
    },
    rpcUrls: {
      default: { http: ["https://edgeware-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://edgscan.live",
        apiUrl: "https://edgscan.live/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18117872
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/edgewareTestnet.js
  var edgewareTestnet = /* @__PURE__ */ defineChain({
    id: 2022,
    name: "Beresheet BereEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Testnet EDG",
      symbol: "tEDG"
    },
    rpcUrls: {
      default: { http: ["https://beresheet-evm.jelliedowl.net"] }
    },
    blockExplorers: {
      default: {
        name: "Edgscan by Bharathcoorg",
        url: "https://testnet.edgscan.live",
        apiUrl: "https://testnet.edgscan.live/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ekta.js
  var ekta = /* @__PURE__ */ defineChain({
    id: 1994,
    name: "Ekta",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://main.ekta.io"] }
    },
    blockExplorers: {
      default: {
        name: "Ektascan",
        url: "https://ektascan.io",
        apiUrl: "https://ektascan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ektaTestnet.js
  var ektaTestnet = /* @__PURE__ */ defineChain({
    id: 1004,
    name: "Ekta Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EKTA",
      symbol: "EKTA"
    },
    rpcUrls: {
      default: { http: ["https://test.ekta.io:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Test Ektascan",
        url: "https://test.ektascan.io",
        apiUrl: "https://test.ektascan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastos.js
  var elastos = /* @__PURE__ */ defineChain({
    id: 20,
    name: "Elastos Smart Chain",
    nativeCurrency: { name: "ELA", symbol: "ELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api2.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc.elastos.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elastosTestnet.js
  var elastosTestnet = /* @__PURE__ */ defineChain({
    id: 21,
    name: "Elastos Smart Chain Testnet",
    nativeCurrency: { name: "tELA", symbol: "tELA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api-testnet.elastos.io/eth"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elastos Explorer",
        url: "https://esc-testnet.elastos.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneum.js
  var electroneum = /* @__PURE__ */ defineChain({
    id: 52014,
    name: "Electroneum Mainnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.electroneum.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/electroneumTestnet.js
  var electroneumTestnet = /* @__PURE__ */ defineChain({
    id: 5201420,
    name: "Electroneum Testnet",
    nativeCurrency: {
      name: "ETN",
      symbol: "ETN",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.electroneum.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Electroneum Block Explorer",
        url: "https://blockexplorer.thesecurityteam.rocks"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/elysiumTestnet.js
  var elysiumTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1338,
    name: "Elysium Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LAVA",
      symbol: "LAVA"
    },
    rpcUrls: {
      default: {
        http: ["https://elysium-test-rpc.vulcanforged.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Elysium testnet explorer",
        url: "https://elysium-explorer.vulcanforged.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eon.js
  var eon = /* @__PURE__ */ defineChain({
    id: 7332,
    name: "Horizen EON",
    nativeCurrency: {
      decimals: 18,
      name: "ZEN",
      symbol: "ZEN"
    },
    rpcUrls: {
      default: { http: ["https://eon-rpc.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "EON Explorer",
        url: "https://eon-explorer.horizenlabs.io"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eos.js
  var eos = /* @__PURE__ */ defineChain({
    id: 17777,
    name: "EOS EVM",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Explorer",
        url: "https://explorer.evm.eosnetwork.com",
        apiUrl: "https://explorer.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 7943933
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/eosTestnet.js
  var eosTestnet = /* @__PURE__ */ defineChain({
    id: 15557,
    name: "EOS EVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "EOS",
      symbol: "EOS"
    },
    rpcUrls: {
      default: { http: ["https://api.testnet.evm.eosnetwork.com"] }
    },
    blockExplorers: {
      default: {
        name: "EOS EVM Testnet Explorer",
        url: "https://explorer.testnet.evm.eosnetwork.com",
        apiUrl: "https://explorer.testnet.evm.eosnetwork.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9067940
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlink.js
  var etherlink = /* @__PURE__ */ defineChain({
    id: 42793,
    name: "Etherlink",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.mainnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink",
        url: "https://explorer.etherlink.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 33899
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/etherlinkTestnet.js
  var etherlinkTestnet = /* @__PURE__ */ defineChain({
    id: 128123,
    name: "Etherlink Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Tez",
      symbol: "XTZ"
    },
    rpcUrls: {
      default: { http: ["https://node.ghostnet.etherlink.com"] }
    },
    blockExplorers: {
      default: {
        name: "Etherlink Testnet",
        url: "https://testnet-explorer.etherlink.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmos.js
  var evmos = /* @__PURE__ */ defineChain({
    id: 9001,
    name: "Evmos",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.org:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Block Explorer",
        url: "https://escan.live"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/evmosTestnet.js
  var evmosTestnet = /* @__PURE__ */ defineChain({
    id: 9e3,
    name: "Evmos Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Evmos",
      symbol: "EVMOS"
    },
    rpcUrls: {
      default: { http: ["https://eth.bd.evmos.dev:8545"] }
    },
    blockExplorers: {
      default: {
        name: "Evmos Testnet Block Explorer",
        url: "https://evm.evmos.dev/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/excelonMainnet.js
  var excelonMainnet = /* @__PURE__ */ defineChain({
    id: 22052002,
    name: "Excelon Mainnet",
    network: "XLON",
    nativeCurrency: {
      decimals: 18,
      name: "Excelon",
      symbol: "xlon"
    },
    rpcUrls: {
      default: {
        http: ["https://edgewallet1.xlon.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Excelon explorer",
        url: "https://explorer.excelon.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantom.js
  var fantom = /* @__PURE__ */ defineChain({
    id: 250,
    name: "Fantom",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/fantom"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://ftmscan.com",
        apiUrl: "https://api.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 33001987
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomSonicTestnet.js
  var fantomSonicTestnet = /* @__PURE__ */ defineChain({
    id: 64240,
    name: "Fantom Sonic Open Testnet",
    network: "fantom-sonic-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpcapi.sonic.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "Fantom Sonic Open Testnet Explorer",
        url: "https://public-sonic.fantom.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fantomTestnet.js
  var fantomTestnet = /* @__PURE__ */ defineChain({
    id: 4002,
    name: "Fantom Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Fantom",
      symbol: "FTM"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.fantom.network"] }
    },
    blockExplorers: {
      default: {
        name: "FTMScan",
        url: "https://testnet.ftmscan.com",
        apiUrl: "https://testnet.ftmscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 8328688
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fibo.js
  var fibo = /* @__PURE__ */ defineChain({
    id: 12306,
    name: "Fibo Chain",
    nativeCurrency: {
      decimals: 18,
      name: "fibo",
      symbol: "FIBO"
    },
    rpcUrls: {
      default: { http: ["https://network.hzroc.art"] }
    },
    blockExplorers: {
      default: {
        name: "FiboScan",
        url: "https://scan.fibochain.org"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoin.js
  var filecoin = /* @__PURE__ */ defineChain({
    id: 314,
    name: "Filecoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "filecoin",
      symbol: "FIL"
    },
    rpcUrls: {
      default: { http: ["https://api.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://filfox.info/en"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3328594
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinCalibration.js
  var filecoinCalibration = /* @__PURE__ */ defineChain({
    id: 314159,
    name: "Filecoin Calibration",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.calibration.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filscan",
        url: "https://calibration.filscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/filecoinHyperspace.js
  var filecoinHyperspace = /* @__PURE__ */ defineChain({
    id: 3141,
    name: "Filecoin Hyperspace",
    nativeCurrency: {
      decimals: 18,
      name: "testnet filecoin",
      symbol: "tFIL"
    },
    rpcUrls: {
      default: { http: ["https://api.hyperspace.node.glif.io/rpc/v1"] }
    },
    blockExplorers: {
      default: {
        name: "Filfox",
        url: "https://hyperspace.filfox.info/en"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flare.js
  var flare = /* @__PURE__ */ defineChain({
    id: 14,
    name: "Flare Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flare",
      symbol: "FLR"
    },
    rpcUrls: {
      default: { http: ["https://flare-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Flare Explorer",
        url: "https://flare-explorer.flare.network",
        apiUrl: "https://flare-explorer.flare.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3002461
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flareTestnet.js
  var flareTestnet = /* @__PURE__ */ defineChain({
    id: 114,
    name: "Flare Testnet Coston2",
    nativeCurrency: {
      decimals: 18,
      name: "Coston2 Flare",
      symbol: "C2FLR"
    },
    rpcUrls: {
      default: { http: ["https://coston2-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston2 Explorer",
        url: "https://coston2-explorer.flare.network",
        apiUrl: "https://coston2-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowMainnet.js
  var flowMainnet = /* @__PURE__ */ defineChain({
    id: 747,
    name: "FlowEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mainnet Explorer",
        url: "https://flowdiver.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowPreviewnet.js
  var flowPreviewnet = /* @__PURE__ */ defineChain({
    id: 646,
    name: "FlowEVM Previewnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Previewnet Explorer",
        url: "https://previewnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6205
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/flowTestnet.js
  var flowTestnet = /* @__PURE__ */ defineChain({
    id: 545,
    name: "FlowEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Flow",
      symbol: "FLOW"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.evm.nodes.onflow.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Flow Diver",
        url: "https://testnet.flowdiver.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 137518
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluence.js
  var fluence = /* @__PURE__ */ defineChain({
    id: 9999999,
    name: "Fluence",
    nativeCurrency: { name: "FLT", symbol: "FLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.fluence.dev"],
        webSocket: ["wss://ws.mainnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.mainnet.fluence.dev",
        apiUrl: "https://blockscout.mainnet.fluence.dev/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceStage.js
  var fluenceStage = /* @__PURE__ */ defineChain({
    id: 123420000220,
    name: "Fluence Stage",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.stage.fluence.dev"],
        webSocket: ["wss://ws.stage.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.stage.fluence.dev",
        apiUrl: "https://blockscout.stage.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fluenceTestnet.js
  var fluenceTestnet = /* @__PURE__ */ defineChain({
    id: 52164803,
    name: "Fluence Testnet",
    nativeCurrency: { name: "tFLT", symbol: "tFLT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.fluence.dev"],
        webSocket: ["wss://ws.testnet.fluence.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.testnet.fluence.dev",
        apiUrl: "https://blockscout.testnet.fluence.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/forma.js
  var forma = /* @__PURE__ */ defineChain({
    id: 984122,
    name: "Forma",
    network: "forma",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.forma.art"],
        webSocket: ["wss://ws.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Forma Explorer",
        url: "https://explorer.forma.art"
      }
    },
    contracts: {
      multicall3: {
        address: "0xd53C6FFB123F7349A32980F87faeD8FfDc9ef079",
        blockCreated: 252705
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/foundry.js
  var foundry = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Foundry",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:8545"],
        webSocket: ["ws://127.0.0.1:8545"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtal.js
  var sourceId14 = 1;
  var fraxtal = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 252,
    name: "Fraxtal",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan",
        url: "https://fraxscan.com",
        apiUrl: "https://api.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId14]: {
          address: "0x66CC916Ed5C6C2FA97014f7D1cD141528Ae171e4"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId14]: {
          address: "0x36cb65c1967A0Fb0EEE11569C51C2f2aA1Ca6f6D",
          blockCreated: 19135323
        }
      },
      l1StandardBridge: {
        [sourceId14]: {
          address: "0x34C0bD5877A5Ee7099D0f5688D65F4bB9158BDE2",
          blockCreated: 19135323
        }
      }
    },
    sourceId: sourceId14
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fraxtalTestnet.js
  var sourceId15 = 17e3;
  var fraxtalTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2522,
    name: "Fraxtal Testnet",
    nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.frax.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "fraxscan testnet",
        url: "https://holesky.fraxscan.com",
        apiUrl: "https://api-holesky.fraxscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId15]: {
          address: "0x715EA64DA13F4d0831ece4Ad3E8c1aa013167F32"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId15]: {
          address: "0xB9c64BfA498d5b9a8398Ed6f46eb76d90dE5505d",
          blockCreated: 318416
        }
      },
      l1StandardBridge: {
        [sourceId15]: {
          address: "0x0BaafC217162f64930909aD9f2B27125121d6332",
          blockCreated: 318416
        }
      }
    },
    sourceId: sourceId15
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiMainnet.js
  var sourceId16 = 1;
  var funkiMainnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 33979,
    name: "Funki",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.funkichain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Mainnet Explorer",
        url: "https://funkiscan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts
    },
    sourceId: sourceId16
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/funkiSepolia.js
  var sourceId17 = 11155111;
  var funkiSepolia = defineChain({
    ...chainConfig2,
    id: 3397901,
    network: "funkiSepolia",
    name: "Funki Sepolia Sandbox",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://funki-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "Funki Sepolia Sandbox Explorer",
        url: "https://sepolia-sandbox.funkichain.com/"
      }
    },
    testnet: true,
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      }
    },
    sourceId: sourceId17
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuse.js
  var fuse = /* @__PURE__ */ defineChain({
    id: 122,
    name: "Fuse",
    nativeCurrency: { name: "Fuse", symbol: "FUSE", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fuse.io"] }
    },
    blockExplorers: {
      default: {
        name: "Fuse Explorer",
        url: "https://explorer.fuse.io",
        apiUrl: "https://explorer.fuse.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 16146628
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fuseSparknet.js
  var fuseSparknet = /* @__PURE__ */ defineChain({
    id: 123,
    name: "Fuse Sparknet",
    nativeCurrency: { name: "Spark", symbol: "SPARK", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.fusespark.io"] }
    },
    blockExplorers: {
      default: {
        name: "Sparkent Explorer",
        url: "https://explorer.fusespark.io",
        apiUrl: "https://explorer.fusespark.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusion.js
  var fusion = /* @__PURE__ */ defineChain({
    id: 32659,
    name: "Fusion Mainnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.fusionnetwork.io"],
        webSocket: ["wss://mainnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10441605
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/fusionTestnet.js
  var fusionTestnet = /* @__PURE__ */ defineChain({
    id: 46688,
    name: "Fusion Testnet",
    nativeCurrency: { name: "Fusion", symbol: "FSN", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.fusionnetwork.io"],
        webSocket: ["wss://testnet.fusionnetwork.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "FSNscan",
        url: "https://testnet.fsnscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10428309
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/garnet.js
  var sourceId18 = 17e3;
  var garnet = defineChain({
    ...chainConfig2,
    name: "Garnet Testnet",
    testnet: true,
    id: 17069,
    sourceId: sourceId18,
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.garnetchain.com"],
        webSocket: ["wss://rpc.garnetchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.garnetchain.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId18]: {
          address: "0x57ee40586fbE286AfC75E67cb69511A6D9aF5909",
          blockCreated: 1274684
        }
      },
      l2OutputOracle: {
        [sourceId18]: {
          address: "0xCb8E7AC561b8EF04F2a15865e9fbc0766FEF569B",
          blockCreated: 1274684
        }
      },
      l1StandardBridge: {
        [sourceId18]: {
          address: "0x09bcDd311FE398F80a78BE37E489f5D440DB95DE",
          blockCreated: 1274684
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/genesys.js
  var genesys = /* @__PURE__ */ defineChain({
    id: 16507,
    name: "Genesys Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "GSYS",
      symbol: "GSYS"
    },
    rpcUrls: {
      default: { http: ["https://rpc.genesys.network"] }
    },
    blockExplorers: {
      default: {
        name: "Genesys Explorer",
        url: "https://gchainexplorer.genesys.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosis.js
  var gnosis = /* @__PURE__ */ defineChain({
    id: 100,
    name: "Gnosis",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gnosischain.com"],
        webSocket: ["wss://rpc.gnosischain.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gnosisscan",
        url: "https://gnosisscan.io",
        apiUrl: "https://api.gnosisscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 21022491
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gnosisChiado.js
  var gnosisChiado = /* @__PURE__ */ defineChain({
    id: 10200,
    name: "Gnosis Chiado",
    nativeCurrency: {
      decimals: 18,
      name: "Gnosis",
      symbol: "xDAI"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.chiadochain.net"],
        webSocket: ["wss://rpc.chiadochain.net/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.chiadochain.net",
        apiUrl: "https://blockscout.chiadochain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4967313
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gobi.js
  var gobi = /* @__PURE__ */ defineChain({
    id: 1663,
    name: "Horizen Gobi Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Test ZEN",
      symbol: "tZEN"
    },
    rpcUrls: {
      default: { http: ["https://gobi-testnet.horizenlabs.io/ethv1"] }
    },
    blockExplorers: {
      default: {
        name: "Gobi Explorer",
        url: "https://gobi-explorer.horizen.io"
      }
    },
    contracts: {},
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goChain.js
  var goChain = /* @__PURE__ */ defineChain({
    id: 60,
    name: "GoChain",
    nativeCurrency: {
      decimals: 18,
      name: "GO",
      symbol: "GO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.gochain.io"] }
    },
    blockExplorers: {
      default: {
        name: "GoChain Explorer",
        url: "https://explorer.gochain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/goerli.js
  var goerli = /* @__PURE__ */ defineChain({
    id: 5,
    name: "Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/eth_goerli"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.etherscan.io",
        apiUrl: "https://api-goerli.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1",
        blockCreated: 10339206
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6507670
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/gravity.js
  var gravity = /* @__PURE__ */ defineChain({
    id: 1625,
    name: "Gravity Alpha Mainnet",
    nativeCurrency: { name: "G", symbol: "G", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.gravity.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Gravity Explorer",
        url: "https://explorer.gravity.xyz",
        apiUrl: "https://explorer.gravity.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xf8ac4BEB2F75d2cFFb588c63251347fdD629B92c",
        blockCreated: 16851
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/guruTestnet.js
  var guruTestnet = /* @__PURE__ */ defineChain({
    id: 261,
    name: "Guru Network Testnet",
    nativeCurrency: {
      name: "testGURU",
      symbol: "tGURU",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.gurunetwork.ai/archive/261"]
      }
    },
    blockExplorers: {
      default: {
        name: "Guruscan",
        url: "https://scan.gurunetwork.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ham.js
  var ham = /* @__PURE__ */ defineChain({
    id: 5112,
    name: "Ham",
    nativeCurrency: {
      decimals: 18,
      name: "Ham",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.ham.fun"],
        webSocket: ["wss://rpc.ham.fun"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ham Chain Explorer",
        url: "https://explorer.ham.fun",
        apiUrl: "https://explorer.ham.fun/api/v2"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqMainnet.js
  var haqqMainnet = /* @__PURE__ */ defineChain({
    id: 11235,
    name: "HAQQ Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.haqq.network",
        apiUrl: "https://explorer.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/haqqTestedge2.js
  var haqqTestedge2 = /* @__PURE__ */ defineChain({
    id: 54211,
    name: "HAQQ Testedge 2",
    nativeCurrency: {
      decimals: 18,
      name: "Islamic Coin",
      symbol: "ISLMT"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.eth.testedge2.haqq.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "HAQQ Explorer",
        url: "https://explorer.testedge2.haqq.network",
        apiUrl: "https://explorer.testedge2.haqq.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hardhat.js
  var hardhat = /* @__PURE__ */ defineChain({
    id: 31337,
    name: "Hardhat",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/harmonyOne.js
  var harmonyOne = /* @__PURE__ */ defineChain({
    id: 16666e5,
    name: "Harmony One",
    nativeCurrency: {
      name: "Harmony",
      symbol: "ONE",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.ankr.com/harmony"] }
    },
    blockExplorers: {
      default: {
        name: "Harmony Explorer",
        url: "https://explorer.harmony.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 24185753
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hashkeyChainTestnet.js
  var hashkeyTestnet = /* @__PURE__ */ defineChain({
    id: 133,
    name: "HashKey Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "HashKey EcoPoints",
      symbol: "HSK"
    },
    rpcUrls: {
      default: {
        http: ["https://hashkeychain-testnet.alt.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "HashKey Chain Explorer",
        url: "https://hashkeychain-testnet-explorer.alt.technology"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hedera.js
  var hedera = /* @__PURE__ */ defineChain({
    id: 295,
    name: "Hedera Mainnet",
    network: "hedera-mainnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/mainnet"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaPreviewnet.js
  var hederaPreviewnet = /* @__PURE__ */ defineChain({
    id: 297,
    name: "Hedera Previewnet",
    network: "hedera-previewnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://previewnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/previewnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hederaTestnet.js
  var hederaTestnet = /* @__PURE__ */ defineChain({
    id: 296,
    name: "Hedera Testnet",
    network: "hedera-testnet",
    nativeCurrency: {
      symbol: "HBAR",
      name: "HBAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.hashio.io/api"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hashscan",
        url: "https://hashscan.io/testnet"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hela.js
  var hela = /* @__PURE__ */ defineChain({
    id: 8668,
    name: "Hela Mainnet",
    nativeCurrency: {
      name: "HLUSD",
      symbol: "HLUSD",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.helachain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hela explorer",
        url: "https://mainnet-blockexplorer.helachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hemiSepolia.js
  var hemiSepolia = /* @__PURE__ */ defineChain({
    id: 743111,
    name: "Hemi Sepolia",
    network: "Hemi Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.hemi.network/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Hemi Sepolia explorer",
        url: "https://testnet.explorer.hemi.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/holesky.js
  var holesky = /* @__PURE__ */ defineChain({
    id: 17e3,
    name: "Holesky",
    nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ethereum-holesky-rpc.publicnode.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://holesky.etherscan.io",
        apiUrl: "https://api-holesky.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 77
      },
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
        blockCreated: 801613
      },
      ensUniversalResolver: {
        address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
        blockCreated: 973484
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychain.js
  var hychain = /* @__PURE__ */ defineChain({
    id: 2911,
    name: "HYCHAIN",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://explorer.hychain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/hychainTestnet.js
  var hychainTestnet = /* @__PURE__ */ defineChain({
    id: 29112,
    name: "HYCHAIN Testnet",
    nativeCurrency: { name: "HYTOPIA", symbol: "TOPIA", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.hychain.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "HYCHAIN Explorer",
        url: "https://testnet-rpc.hychain.com/http"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvm.js
  var immutableZkEvm = /* @__PURE__ */ defineChain({
    id: 13371,
    name: "Immutable zkEVM",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Explorer",
        url: "https://explorer.immutable.com",
        apiUrl: "https://explorer.immutable.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x236bdA4589e44e6850f5aC6a74BfCa398a86c6c0",
        blockCreated: 4335972
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/immutableZkEvmTestnet.js
  var immutableZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 13473,
    name: "Immutable zkEVM Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Immutable Coin",
      symbol: "IMX"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.immutable.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Immutable Testnet Explorer",
        url: "https://explorer.testnet.immutable.com/"
      }
    },
    contracts: {
      multicall3: {
        address: "0x2CC787Ed364600B0222361C4188308Fa8E68bA60",
        blockCreated: 5977391
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/inEVM.js
  var inEVM = /* @__PURE__ */ defineChain({
    id: 2525,
    name: "inEVM Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Injective",
      symbol: "INJ"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.rpc.inevm.com/http"] }
    },
    blockExplorers: {
      default: {
        name: "inEVM Explorer",
        url: "https://inevm.calderaexplorer.xyz",
        apiUrl: "https://inevm.calderaexplorer.xyz/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 118606
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iota.js
  var iota = /* @__PURE__ */ defineChain({
    id: 8822,
    name: "IOTA EVM",
    network: "iotaevm",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.iota.org",
        apiUrl: "https://explorer.evm.iota.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 25022
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotaTestnet.js
  var iotaTestnet = /* @__PURE__ */ defineChain({
    id: 1075,
    name: "IOTA EVM Testnet",
    network: "iotaevm-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IOTA",
      symbol: "IOTA"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.iotaledger.net"],
        webSocket: ["wss://ws.json-rpc.evm.testnet.iotaledger.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.evm.testnet.iotaledger.net",
        apiUrl: "https://explorer.evm.testnet.iotaledger.net/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotex.js
  var iotex = /* @__PURE__ */ defineChain({
    id: 4689,
    name: "IoTeX",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.mainnet.iotex.io"],
        webSocket: ["wss://babel-api.mainnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 22163670
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/iotexTestnet.js
  var iotexTestnet = /* @__PURE__ */ defineChain({
    id: 4690,
    name: "IoTeX Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IoTeX",
      symbol: "IOTX"
    },
    rpcUrls: {
      default: {
        http: ["https://babel-api.testnet.iotex.io"],
        webSocket: ["wss://babel-api.testnet.iotex.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "IoTeXScan",
        url: "https://testnet.iotexscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xb5cecD6894c6f473Ec726A176f1512399A2e355d",
        blockCreated: 24347592
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbc.js
  var jbc = /* @__PURE__ */ defineChain({
    id: 8899,
    name: "JIBCHAIN L1",
    network: "jbc",
    nativeCurrency: { name: "JBC", symbol: "JBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-l1.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp-l1.jibchain.net",
        apiUrl: "https://exp-l1.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc0C8C486D1466C57Efe13C2bf000d4c56F47CBdC",
        blockCreated: 2299048
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/jbcTestnet.js
  var jbcTestnet = /* @__PURE__ */ defineChain({
    id: 88991,
    name: "Jibchain Testnet",
    nativeCurrency: { name: "tJBC", symbol: "tJBC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.jibchain.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.testnet.jibchain.net",
        apiUrl: "https://exp.testnet.jibchain.net/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xa1a858ad9041B4741e620355a3F96B3c78e70ecE",
        blockCreated: 32848
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/karura.js
  var karura = /* @__PURE__ */ defineChain({
    id: 686,
    name: "Karura",
    network: "karura",
    nativeCurrency: {
      name: "Karura",
      symbol: "KAR",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-karura.aca-api.network"],
        webSocket: ["wss://eth-rpc-karura.aca-api.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Karura Blockscout",
        url: "https://blockscout.karura.network",
        apiUrl: "https://blockscout.karura.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotSepolia.js
  var kakarotSepolia = /* @__PURE__ */ defineChain({
    id: 1802203764,
    name: "Kakarot Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kakarotStarknetSepolia.js
  var kakarotStarknetSepolia = /* @__PURE__ */ defineChain({
    id: 920637907288165,
    name: "Kakarot Starknet Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.kakarot.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kakarot Scan",
        url: "https://sepolia.kakarotscan.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kava.js
  var kava = /* @__PURE__ */ defineChain({
    id: 2222,
    name: "Kava EVM",
    network: "kava-mainnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Explorer",
        url: "https://kavascan.com",
        apiUrl: "https://kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3661165
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kavaTestnet.js
  var kavaTestnet = /* @__PURE__ */ defineChain({
    id: 2221,
    name: "Kava EVM Testnet",
    network: "kava-testnet",
    nativeCurrency: {
      name: "Kava",
      symbol: "KAVA",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://evm.testnet.kava.io"] }
    },
    blockExplorers: {
      default: {
        name: "Kava EVM Testnet Explorer",
        url: "https://testnet.kavascan.com/",
        apiUrl: "https://testnet.kavascan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xDf1D724A7166261eEB015418fe8c7679BBEa7fd6",
        blockCreated: 7242179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kcc.js
  var kcc = /* @__PURE__ */ defineChain({
    id: 321,
    name: "KCC Mainnet",
    network: "KCC Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "KCS",
      symbol: "KCS"
    },
    rpcUrls: {
      default: {
        http: ["https://kcc-rpc.com"]
      }
    },
    blockExplorers: {
      default: { name: "KCC Explorer", url: "https://explorer.kcc.io" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 11760430
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kinto.js
  var kinto = /* @__PURE__ */ defineChain({
    id: 7887,
    name: "Kinto Mainnet",
    network: "Kinto Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.kinto.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Kinto Explorer",
        url: "https://explorer.kinto.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytn.js
  var klaytn = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Klaytn",
    nativeCurrency: {
      decimals: 18,
      name: "Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-cypress.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://scope.klaytn.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kaia.js
  var kaia = /* @__PURE__ */ defineChain({
    id: 8217,
    name: "Kaia",
    nativeCurrency: {
      decimals: 18,
      name: "Kaia",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kaiascan.io",
        apiUrl: "https://api-cypress.klaytnscope.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 96002415
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kairos.js
  var kairos = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Kairos Testnet",
    network: "kairos",
    nativeCurrency: {
      decimals: 18,
      name: "Kairos KAIA",
      symbol: "KAIA"
    },
    rpcUrls: {
      default: { http: ["https://public-en-kairos.node.kaia.io"] }
    },
    blockExplorers: {
      default: {
        name: "KaiaScan",
        url: "https://kairos.kaiascan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/klaytnBaobab.js
  var klaytnBaobab = /* @__PURE__ */ defineChain({
    id: 1001,
    name: "Klaytn Baobab Testnet",
    network: "klaytn-baobab",
    nativeCurrency: {
      decimals: 18,
      name: "Baobab Klaytn",
      symbol: "KLAY"
    },
    rpcUrls: {
      default: { http: ["https://public-en-baobab.klaytn.net"] }
    },
    blockExplorers: {
      default: {
        name: "KlaytnScope",
        url: "https://baobab.klaytnscope.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 123390593
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/koi.js
  var koi = defineChain({
    id: 701,
    name: "Koi Network",
    nativeCurrency: {
      decimals: 18,
      name: "Koi Network Native Token",
      symbol: "KRING"
    },
    rpcUrls: {
      default: {
        http: ["https://koi-rpc.darwinia.network"],
        webSocket: ["wss://koi-rpc.darwinia.network"]
      }
    },
    blockExplorers: {
      default: { name: "Blockscout", url: "https://koi-scan.darwinia.network" }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 180001
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kroma.js
  var kroma = /* @__PURE__ */ defineChain({
    id: 255,
    name: "Kroma",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Explorer",
        url: "https://blockscout.kroma.network",
        apiUrl: "https://blockscout.kroma.network/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/kromaSepolia.js
  var kromaSepolia = /* @__PURE__ */ defineChain({
    id: 2358,
    name: "Kroma Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.sepolia.kroma.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Kroma Sepolia Explorer",
        url: "https://blockscout.sepolia.kroma.network",
        apiUrl: "https://blockscout.sepolia.kroma.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3x.js
  var l3x = /* @__PURE__ */ defineChain({
    id: 12324,
    name: "L3X Protocol",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-mainnet.l3x.com"],
        webSocket: ["wss://rpc-mainnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Mainnet Explorer",
        url: "https://explorer.l3x.com",
        apiUrl: "https://explorer.l3x.com/api/v2"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/l3xTestnet.js
  var l3xTestnet = /* @__PURE__ */ defineChain({
    id: 12325,
    name: "L3X Protocol Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.l3x.com"],
        webSocket: ["wss://rpc-testnet.l3x.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "L3X Testnet Explorer",
        url: "https://explorer-testnet.l3x.com",
        apiUrl: "https://explorer-testnet.l3x.com/api/v2"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lavita.js
  var lavita = /* @__PURE__ */ defineChain({
    id: 360890,
    name: "LAVITA Mainnet",
    nativeCurrency: { name: "vTFUEL", symbol: "vTFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://tsub360890-eth-rpc.thetatoken.org/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "LAVITA Explorer",
        url: "https://tsub360890-explorer.thetatoken.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPegasus.js
  var lightlinkPegasus = /* @__PURE__ */ defineChain({
    id: 1891,
    name: "LightLink Pegasus Testnet",
    network: "lightlink-pegasus",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.pegasus.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Pegasus Explorer",
        url: "https://pegasus.lightlink.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lightlinkPhoenix.js
  var lightlinkPhoenix = /* @__PURE__ */ defineChain({
    id: 1890,
    name: "LightLink Phoenix Mainnet",
    network: "lightlink-phoenix",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://replicator.phoenix.lightlink.io/rpc/v1"]
      }
    },
    blockExplorers: {
      default: {
        name: "LightLink Phoenix Explorer",
        url: "https://phoenix.lightlink.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/actions/estimateGas.js
  init_parseAccount();
  init_toHex();
  init_getCallError();
  init_extract();
  init_transactionRequest();
  init_assertRequest();
  async function estimateGas2(client, args) {
    const { account: account_ = client.account } = args;
    if (!account_)
      throw new AccountNotFoundError();
    const account = parseAccount(account_);
    try {
      const { accessList, blockNumber, blockTag, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
      const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
      const block = blockNumberHex || blockTag;
      assertRequest(args);
      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
      const format = chainFormat || formatTransactionRequest;
      const request = format({
        // Pick out extra data that might exist on the chain's transaction request type.
        ...extract(rest, { format: chainFormat }),
        from: account?.address,
        accessList,
        data,
        gas,
        gasPrice,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        to,
        value
      });
      const { baseFeePerGas, gasLimit, priorityFeePerGas } = await client.request({
        method: "linea_estimateGas",
        params: block ? [request, block] : [request]
      });
      return {
        baseFeePerGas: BigInt(baseFeePerGas),
        gasLimit: BigInt(gasLimit),
        priorityFeePerGas: BigInt(priorityFeePerGas)
      };
    } catch (err) {
      throw getCallError(err, {
        ...args,
        account,
        chain: client.chain
      });
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/linea/chainConfig.js
  var chainConfig4 = {
    fees: {
      estimateFeesPerGas: estimateFeesPerGas2,
      async maxPriorityFeePerGas({ block, client, request }) {
        const response = await estimateFeesPerGas2({
          block,
          client,
          multiply: (x) => x,
          request,
          type: "eip1559"
        });
        if (!response?.maxPriorityFeePerGas)
          return null;
        return response.maxPriorityFeePerGas;
      }
    }
  };
  async function estimateFeesPerGas2({ client, multiply, request, type }) {
    try {
      const response = await estimateGas2(client, {
        ...request,
        account: request?.account
      });
      const { priorityFeePerGas: maxPriorityFeePerGas } = response;
      const baseFeePerGas = multiply(BigInt(response.baseFeePerGas));
      const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
      if (type === "legacy")
        return { gasPrice: maxFeePerGas };
      return {
        maxFeePerGas,
        maxPriorityFeePerGas
      };
    } catch {
      return null;
    }
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/linea.js
  var linea = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59144,
    name: "Linea Mainnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.linea.build"],
        webSocket: ["wss://rpc.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://lineascan.build",
        apiUrl: "https://api.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 42
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaGoerli.js
  var lineaGoerli = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://api-goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaSepolia.js
  var lineaSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig4,
    id: 59141,
    name: "Linea Sepolia Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia.linea.build"],
        webSocket: ["wss://rpc.sepolia.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.lineascan.build",
        apiUrl: "https://api-sepolia.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 227427
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lineaTestnet.js
  var lineaTestnet = /* @__PURE__ */ defineChain({
    id: 59140,
    name: "Linea Goerli Testnet",
    nativeCurrency: { name: "Linea Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.goerli.linea.build"],
        webSocket: ["wss://rpc.goerli.linea.build"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli.lineascan.build",
        apiUrl: "https://goerli.lineascan.build/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 498623
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lisk.js
  var sourceId19 = 1;
  var lisk = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1135,
    name: "Lisk",
    network: "lisk",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://blockscout.lisk.com",
        apiUrl: "https://blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0"
      },
      l2OutputOracle: {
        [sourceId19]: {
          address: "0x113cB99283AF242Da0A0C54347667edF531Aa7d6"
        }
      },
      portal: {
        [sourceId19]: {
          address: "0x26dB93F8b8b4f7016240af62F7730979d353f9A7"
        }
      },
      l1StandardBridge: {
        [sourceId19]: {
          address: "0x2658723Bf70c7667De6B25F99fcce13A16D25d08"
        }
      }
    },
    sourceId: sourceId19
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/liskSepolia.js
  var sourceId20 = 11155111;
  var liskSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4202,
    network: "lisk-sepolia",
    name: "Lisk Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.sepolia-api.lisk.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia-blockscout.lisk.com",
        apiUrl: "https://sepolia-blockscout.lisk.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId20]: {
          address: "0xA0E35F56C318DE1bD5D9ca6A94Fe7e37C5663348"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId20]: {
          address: "0xe3d90F21490686Ec7eF37BE788E02dfC12787264"
        }
      },
      l1StandardBridge: {
        [sourceId20]: {
          address: "0x1Fb30e446eA791cd1f011675E5F3f5311b70faF5"
        }
      }
    },
    testnet: true,
    sourceId: sourceId20
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/localhost.js
  var localhost = /* @__PURE__ */ defineChain({
    id: 1337,
    name: "Localhost",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["http://127.0.0.1:8545"] }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/loop.js
  var loop = /* @__PURE__ */ defineChain({
    id: 15551,
    name: "LoopNetwork Mainnet",
    nativeCurrency: {
      name: "LOOP",
      symbol: "LOOP",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://api.mainnetloop.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "LoopNetwork Blockchain Explorer",
        url: "https://explorer.mainnetloop.com/"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lukso.js
  var lukso = /* @__PURE__ */ defineChain({
    id: 42,
    network: "lukso",
    name: "LUKSO",
    nativeCurrency: {
      name: "LUKSO",
      symbol: "LYX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.lukso.network"],
        webSocket: ["wss://ws-rpc.mainnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Mainnet Explorer",
        url: "https://explorer.execution.mainnet.lukso.network",
        apiUrl: "https://api.explorer.execution.mainnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 468183
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/luksoTestnet.js
  var luksoTestnet = /* @__PURE__ */ defineChain({
    id: 4201,
    name: "LUKSO Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "LUKSO Testnet",
      symbol: "LYXt"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.lukso.network"],
        webSocket: ["wss://ws-rpc.testnet.lukso.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "LUKSO Testnet Explorer",
        url: "https://explorer.execution.testnet.lukso.network",
        apiUrl: "https://api.explorer.execution.testnet.lukso.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 605348
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lycan.js
  var lycan = /* @__PURE__ */ defineChain({
    id: 721,
    name: "Lycan",
    nativeCurrency: {
      decimals: 18,
      name: "Lycan",
      symbol: "LYC"
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.lycanchain.com",
          "https://us-east.lycanchain.com",
          "https://us-west.lycanchain.com",
          "https://eu-north.lycanchain.com",
          "https://eu-west.lycanchain.com",
          "https://asia-southeast.lycanchain.com"
        ],
        webSocket: [
          "wss://rpc.lycanchain.com",
          "wss://us-east.lycanchain.com",
          "wss://us-west.lycanchain.com",
          "wss://eu-north.lycanchain.com",
          "wss://eu-west.lycanchain.com",
          "wss://asia-southeast.lycanchain.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Lycan Explorer",
        url: "https://explorer.lycanchain.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/lyra.js
  var lyra = /* @__PURE__ */ defineChain({
    id: 957,
    name: "Lyra Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.lyra.finance"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lyra Explorer",
        url: "https://explorer.lyra.finance",
        apiUrl: "https://explorer.lyra.finance/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1935198
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mainnet.js
  var mainnet = /* @__PURE__ */ defineChain({
    id: 1,
    name: "Ethereum",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://cloudflare-eth.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://etherscan.io",
        apiUrl: "https://api.etherscan.io/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      ensUniversalResolver: {
        address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67",
        blockCreated: 19258213
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mandala.js
  var mandala = /* @__PURE__ */ defineChain({
    id: 595,
    name: "Mandala TC9",
    network: "mandala",
    nativeCurrency: {
      name: "Mandala",
      symbol: "mACA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://eth-rpc-tc9.aca-staging.network"],
        webSocket: ["wss://eth-rpc-tc9.aca-staging.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mandala Blockscout",
        url: "https://blockscout.mandala.aca-staging.network",
        apiUrl: "https://blockscout.mandala.aca-staging.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/manta.js
  var manta = /* @__PURE__ */ defineChain({
    id: 169,
    name: "Manta Pacific Mainnet",
    network: "manta",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://pacific-rpc.manta.network/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Explorer",
        url: "https://pacific-explorer.manta.network",
        apiUrl: "https://pacific-explorer.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 332890
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaSepoliaTestnet.js
  var mantaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 3441006,
    name: "Manta Pacific Sepolia Testnet",
    network: "manta-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://pacific-rpc.sepolia-testnet.manta.network/http"]
      }
    },
    blockExplorers: {
      default: {
        name: "Manta Sepolia Testnet Explorer",
        url: "https://pacific-explorer.sepolia-testnet.manta.network",
        apiUrl: "https://pacific-explorer.sepolia-testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca54918f7B525C8df894668846506767412b53E3",
        blockCreated: 479584
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantaTestnet.js
  var mantaTestnet = /* @__PURE__ */ defineChain({
    id: 3441005,
    name: "Manta Pacific Testnet",
    network: "manta-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://manta-testnet.calderachain.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Manta Testnet Explorer",
        url: "https://pacific-explorer.testnet.manta.network",
        apiUrl: "https://pacific-explorer.testnet.manta.network/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x211B1643b95Fe76f11eD8880EE810ABD9A4cf56C",
        blockCreated: 419915
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantle.js
  var mantle = /* @__PURE__ */ defineChain({
    id: 5e3,
    name: "Mantle",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Explorer",
        url: "https://mantlescan.xyz/",
        apiUrl: "https://api.mantlescan.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 304717
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleSepoliaTestnet.js
  var mantleSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 5003,
    name: "Mantle Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.sepolia.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.sepolia.mantle.xyz/",
        apiUrl: "https://explorer.sepolia.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4584012
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mantleTestnet.js
  var mantleTestnet = /* @__PURE__ */ defineChain({
    id: 5001,
    name: "Mantle Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MNT",
      symbol: "MNT"
    },
    rpcUrls: {
      default: { http: ["https://rpc.testnet.mantle.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Mantle Testnet Explorer",
        url: "https://explorer.testnet.mantle.xyz",
        apiUrl: "https://explorer.testnet.mantle.xyz/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 561333
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mapProtocol.js
  var mapProtocol = /* @__PURE__ */ defineChain({
    id: 22776,
    name: "MAP Protocol",
    nativeCurrency: {
      decimals: 18,
      name: "MAPO",
      symbol: "MAPO"
    },
    rpcUrls: {
      default: { http: ["https://rpc.maplabs.io"] }
    },
    blockExplorers: {
      default: {
        name: "MAPO Scan",
        url: "https://maposcan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchain.js
  var matchain = /* @__PURE__ */ defineChain({
    id: 698,
    name: "Matchain",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://matchscan.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/matchainTestnet.js
  var matchainTestnet = /* @__PURE__ */ defineChain({
    id: 699,
    name: "Matchain Testnet",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.matchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Matchain Scan",
        url: "https://testnet.matchscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/merlin.js
  var merlin = /* @__PURE__ */ defineChain({
    id: 4200,
    name: "Merlin",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.merlinchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://scan.merlinchain.io",
        apiUrl: "https://scan.merlinchain.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachain.js
  var metachain = /* @__PURE__ */ defineChain({
    id: 571,
    name: "MetaChain Mainnet",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.metatime.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://explorer.metatime.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metachainIstanbul.js
  var metachainIstanbul = /* @__PURE__ */ defineChain({
    id: 1453,
    name: "MetaChain Istanbul",
    nativeCurrency: { name: "Metatime Coin", symbol: "MTC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://istanbul-rpc.metachain.dev"]
      }
    },
    blockExplorers: {
      default: {
        name: "MetaExplorer",
        url: "https://istanbul-explorer.metachain.dev"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0000000000000000000000000000000000003001",
        blockCreated: 0
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metalL2.js
  var sourceId21 = 1;
  var metalL2 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1750,
    name: "Metal L2",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.metall2.com"],
        webSocket: ["wss://rpc.metall2.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.metall2.com",
        apiUrl: "https://explorer.metall2.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId21]: {
          address: "0x3B1F7aDa0Fcc26B13515af752Dd07fB1CAc11426"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 0
      },
      portal: {
        [sourceId21]: {
          address: "0x3F37aBdE2C6b5B2ed6F8045787Df1ED1E3753956"
        }
      },
      l1StandardBridge: {
        [sourceId21]: {
          address: "0x6d0f65D59b55B0FEC5d2d15365154DcADC140BF3"
        }
      }
    },
    sourceId: sourceId21
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meter.js
  var meter = /* @__PURE__ */ defineChain({
    id: 82,
    name: "Meter",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpc.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterScan",
        url: "https://scan.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/meterTestnet.js
  var meterTestnet = /* @__PURE__ */ defineChain({
    id: 83,
    name: "Meter Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MTR",
      symbol: "MTR"
    },
    rpcUrls: {
      default: { http: ["https://rpctest.meter.io"] }
    },
    blockExplorers: {
      default: {
        name: "MeterTestnetScan",
        url: "https://scan-warringstakes.meter.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metis.js
  var metis = /* @__PURE__ */ defineChain({
    id: 1088,
    name: "Metis",
    nativeCurrency: {
      decimals: 18,
      name: "Metis",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://andromeda.metis.io/?owner=1088"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Explorer",
        url: "https://explorer.metis.io",
        apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2338552
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/metisGoerli.js
  var metisGoerli = /* @__PURE__ */ defineChain({
    id: 599,
    name: "Metis Goerli",
    nativeCurrency: {
      decimals: 18,
      name: "Metis Goerli",
      symbol: "METIS"
    },
    rpcUrls: {
      default: { http: ["https://goerli.gateway.metisdevops.link"] }
    },
    blockExplorers: {
      default: {
        name: "Metis Goerli Explorer",
        url: "https://goerli.explorer.metisdevops.link",
        apiUrl: "https://goerli.explorer.metisdevops.link/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1006207
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mev.js
  var mev = /* @__PURE__ */ defineChain({
    id: 7518,
    name: "MEVerse Chain Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversemainnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://www.meversescan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 86881340
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mevTestnet.js
  var mevTestnet = /* @__PURE__ */ defineChain({
    id: 4759,
    name: "MEVerse Chain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "MEVerse",
      symbol: "MEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.meversetestnet.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.meversescan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 64371115
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mint.js
  var mint = /* @__PURE__ */ defineChain({
    id: 185,
    name: "Mint Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain explorer",
        url: "https://explorer.mintchain.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mintSepoliaTestnet.js
  var mintSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 1686,
    name: "Mint Sepolia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.mintchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Mintchain Testnet explorer",
        url: "https://testnet-explorer.mintchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/mode.js
  var sourceId22 = 1;
  var mode = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 34443,
    name: "Mode Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Modescan",
        url: "https://modescan.io"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 2465882
      },
      l2OutputOracle: {
        [sourceId22]: {
          address: "0x4317ba146D4933D889518a3e5E11Fe7a53199b04"
        }
      },
      portal: {
        [sourceId22]: {
          address: "0x8B34b14c7c7123459Cf3076b8Cb929BE097d0C07"
        }
      },
      l1StandardBridge: {
        [sourceId22]: {
          address: "0x735aDBbE72226BD52e818E7181953f42E3b0FF21"
        }
      }
    },
    sourceId: sourceId22
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/modeTestnet.js
  var sourceId23 = 11155111;
  var modeTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 919,
    name: "Mode Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.mode.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://sepolia.explorer.mode.network",
        apiUrl: "https://sepolia.explorer.mode.network/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId23]: {
          address: "0x2634BD65ba27AB63811c74A63118ACb312701Bfa",
          blockCreated: 3778393
        }
      },
      portal: {
        [sourceId23]: {
          address: "0x320e1580effF37E008F1C92700d1eBa47c1B23fD",
          blockCreated: 3778395
        }
      },
      l1StandardBridge: {
        [sourceId23]: {
          address: "0xbC5C679879B2965296756CD959C3C739769995E2",
          blockCreated: 3778392
        }
      },
      multicall3: {
        address: "0xBAba8373113Fb7a68f195deF18732e01aF8eDfCF",
        blockCreated: 3019007
      }
    },
    testnet: true,
    sourceId: sourceId23
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbaseAlpha.js
  var moonbaseAlpha = /* @__PURE__ */ defineChain({
    id: 1287,
    name: "Moonbase Alpha",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.api.moonbase.moonbeam.network"],
        webSocket: ["wss://wss.api.moonbase.moonbeam.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonbase.moonscan.io",
        apiUrl: "https://moonbase.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1850686
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeam.js
  var moonbeam = /* @__PURE__ */ defineChain({
    id: 1284,
    name: "Moonbeam",
    nativeCurrency: {
      decimals: 18,
      name: "GLMR",
      symbol: "GLMR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonbeam.public.blastapi.io"],
        webSocket: ["wss://moonbeam.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonscan.io",
        apiUrl: "https://api-moonbeam.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 609002
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonbeamDev.js
  var moonbeamDev = /* @__PURE__ */ defineChain({
    id: 1281,
    name: "Moonbeam Development Node",
    nativeCurrency: {
      decimals: 18,
      name: "DEV",
      symbol: "DEV"
    },
    rpcUrls: {
      default: {
        http: ["http://127.0.0.1:9944"],
        webSocket: ["wss://127.0.0.1:9944"]
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/moonriver.js
  var moonriver = /* @__PURE__ */ defineChain({
    id: 1285,
    name: "Moonriver",
    nativeCurrency: {
      decimals: 18,
      name: "MOVR",
      symbol: "MOVR"
    },
    rpcUrls: {
      default: {
        http: ["https://moonriver.public.blastapi.io"],
        webSocket: ["wss://moonriver.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Moonscan",
        url: "https://moonriver.moonscan.io",
        apiUrl: "https://api-moonriver.moonscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1597904
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphHolesky.js
  var morphHolesky = /* @__PURE__ */ defineChain({
    id: 2810,
    name: "Morph Holesky",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-quicknode-holesky.morphl2.io"],
        webSocket: ["wss://rpc-quicknode-holesky.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Holesky Explorer",
        url: "https://explorer-holesky.morphl2.io",
        apiUrl: "https://explorer-api-holesky.morphl2.io/api?"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/morphSepolia.js
  var morphSepolia = /* @__PURE__ */ defineChain({
    id: 2710,
    name: "Morph Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.morphl2.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Morph Testnet Explorer",
        url: "https://explorer-testnet.morphl2.io",
        apiUrl: "https://explorer-api-testnet.morphl2.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nautilus.js
  var nautilus = /* @__PURE__ */ defineChain({
    id: 22222,
    name: "Nautilus Mainnet",
    nativeCurrency: { name: "ZBC", symbol: "ZBC", decimals: 9 },
    rpcUrls: {
      default: {
        http: ["https://api.nautilus.nautchain.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "NautScan",
        url: "https://nautscan.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonDevnet.js
  var neonDevnet = /* @__PURE__ */ defineChain({
    id: 245022926,
    name: "Neon EVM DevNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://devnet.neonevm.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://devnet.neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 205206112
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/neonMainnet.js
  var neonMainnet = /* @__PURE__ */ defineChain({
    id: 245022934,
    network: "neonMainnet",
    name: "Neon EVM MainNet",
    nativeCurrency: { name: "NEON", symbol: "NEON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://neon-proxy-mainnet.solana.p2p.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Neonscan",
        url: "https://neonscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 206545524
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexi.js
  var nexi = /* @__PURE__ */ defineChain({
    id: 4242,
    name: "Nexi",
    nativeCurrency: { name: "Nexi", symbol: "NEXI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.chain.nexi.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "NexiScan",
        url: "https://www.nexiscan.com",
        apiUrl: "https://www.nexiscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0277A46Cc69A57eE3A6C8c158bA874832F718B8E",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/nexilix.js
  var nexilix = /* @__PURE__ */ defineChain({
    id: 240,
    name: "Nexilix Smart Chain",
    nativeCurrency: {
      decimals: 18,
      name: "Nexilix",
      symbol: "NEXILIX"
    },
    rpcUrls: {
      default: { http: ["https://rpcurl.pos.nexilix.com"] }
    },
    blockExplorers: {
      default: {
        name: "NexilixScan",
        url: "https://scan.nexilix.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x58381c8e2BF9d0C2C4259cA14BdA9Afe02831244",
        blockCreated: 74448
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasisTestnet.js
  var oasisTestnet = /* @__PURE__ */ defineChain({
    id: 4090,
    network: "oasis-testnet",
    name: "Oasis Testnet",
    nativeCurrency: { name: "Fasttoken", symbol: "FTN", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc1.oasis.bahamutchain.com"] }
    },
    blockExplorers: {
      default: {
        name: "Ftnscan",
        url: "https://oasis.ftnscan.com",
        apiUrl: "https://oasis.ftnscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oasys.js
  var oasys = /* @__PURE__ */ defineChain({
    id: 248,
    name: "Oasys",
    nativeCurrency: { name: "Oasys", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.oasys.games"]
      }
    },
    blockExplorers: {
      default: {
        name: "OasysScan",
        url: "https://scan.oasys.games",
        apiUrl: "https://scan.oasys.games/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/odysseyTestnet.js
  var odysseyTestnet = /* @__PURE__ */ defineChain({
    id: 911867,
    name: "Odyssey Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://odyssey.ithaca.xyz"] }
    },
    blockExplorers: {
      default: {
        name: "Odyssey Explorer",
        url: "https://odyssey-explorer.ithaca.xyz",
        apiUrl: "https://odyssey-explorer.ithaca.xyz/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/okc.js
  var okc = /* @__PURE__ */ defineChain({
    id: 66,
    name: "OKC",
    nativeCurrency: {
      decimals: 18,
      name: "OKT",
      symbol: "OKT"
    },
    rpcUrls: {
      default: { http: ["https://exchainrpc.okex.org"] }
    },
    blockExplorers: {
      default: {
        name: "oklink",
        url: "https://www.oklink.com/okc"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 10364792
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/oortmainnetDev.js
  var oortMainnetDev = /* @__PURE__ */ defineChain({
    id: 9700,
    name: "OORT MainnetDev",
    nativeCurrency: {
      decimals: 18,
      name: "OORT",
      symbol: "OORT"
    },
    rpcUrls: {
      default: { http: ["https://dev-rpc.oortech.com"] }
    },
    blockExplorers: {
      default: {
        name: "OORT MainnetDev Explorer",
        url: "https://dev-scan.oortech.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNB.js
  var sourceId24 = 56;
  var opBNB = /* @__PURE__ */ defineChain({
    id: 204,
    name: "opBNB",
    nativeCurrency: {
      name: "BNB",
      symbol: "BNB",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://opbnb-mainnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opBNB (BSCScan)",
        url: "https://opbnb.bscscan.com",
        apiUrl: "https://api-opbnb.bscscan.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 512881
      },
      l2OutputOracle: {
        [sourceId24]: {
          address: "0x153CAB79f4767E2ff862C94aa49573294B13D169"
        }
      },
      portal: {
        [sourceId24]: {
          address: "0x1876EA7702C0ad0C6A2ae6036DE7733edfBca519"
        }
      },
      l1StandardBridge: {
        [sourceId24]: {
          address: "0xF05F0e4362859c3331Cb9395CBC201E3Fa6757Ea"
        }
      }
    },
    sourceId: sourceId24
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/opBNBTestnet.js
  var sourceId25 = 97;
  var opBNBTestnet = /* @__PURE__ */ defineChain({
    id: 5611,
    name: "opBNB Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "tBNB",
      symbol: "tBNB"
    },
    rpcUrls: {
      default: { http: ["https://opbnb-testnet-rpc.bnbchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "opbnbscan",
        url: "https://testnet.opbnbscan.com"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3705108
      },
      l2OutputOracle: {
        [sourceId25]: {
          address: "0xFf2394Bb843012562f4349C6632a0EcB92fC8810"
        }
      },
      portal: {
        [sourceId25]: {
          address: "0x4386C8ABf2009aC0c263462Da568DD9d46e52a31"
        }
      },
      l1StandardBridge: {
        [sourceId25]: {
          address: "0x677311Fd2cCc511Bbc0f581E8d9a07B033D5E840"
        }
      }
    },
    testnet: true,
    sourceId: sourceId25
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimism.js
  var sourceId26 = 1;
  var optimism = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 10,
    name: "OP Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Optimism Explorer",
        url: "https://optimistic.etherscan.io",
        apiUrl: "https://api-optimistic.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId26]: {
          address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
        }
      },
      l2OutputOracle: {
        [sourceId26]: {
          address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 4286263
      },
      portal: {
        [sourceId26]: {
          address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
        }
      },
      l1StandardBridge: {
        [sourceId26]: {
          address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
        }
      }
    },
    sourceId: sourceId26
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismGoerli.js
  var sourceId27 = 5;
  var optimismGoerli = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 420,
    name: "Optimism Goerli",
    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://goerli.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://goerli-optimism.etherscan.io",
        apiUrl: "https://goerli-optimism.etherscan.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId27]: {
          address: "0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 49461
      },
      portal: {
        [sourceId27]: {
          address: "0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"
        }
      },
      l1StandardBridge: {
        [sourceId27]: {
          address: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"
        }
      }
    },
    testnet: true,
    sourceId: sourceId27
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optimismSepolia.js
  var sourceId28 = 11155111;
  var optimismSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11155420,
    name: "OP Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.optimism.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://optimism-sepolia.blockscout.com",
        apiUrl: "https://optimism-sepolia.blockscout.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId28]: {
          address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
        }
      },
      l2OutputOracle: {
        [sourceId28]: {
          address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1620204
      },
      portal: {
        [sourceId28]: {
          address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
        }
      },
      l1StandardBridge: {
        [sourceId28]: {
          address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
        }
      }
    },
    testnet: true,
    sourceId: sourceId28
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopia.js
  var optopia = /* @__PURE__ */ defineChain({
    id: 62050,
    name: "Optopia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-mainnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan.optopia.ai"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/optopiaTestnet.js
  var optopiaTestnet = /* @__PURE__ */ defineChain({
    id: 62049,
    name: "Optopia Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-testnet.optopia.ai"] }
    },
    blockExplorers: {
      default: {
        name: "Optopia Explorer",
        url: "https://scan-testnet.optopia.ai"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderly.js
  var orderly = /* @__PURE__ */ defineChain({
    id: 291,
    name: "Orderly",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.orderly.network"] }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorer.orderly.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/orderlySepolia.js
  var orderlySepolia = /* @__PURE__ */ defineChain({
    id: 4460,
    name: "Orderly Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://l2-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Orderly Explorer",
        url: "https://explorerl2new-orderly-l2-4460-sepolia-8tc3sd7dvy.t.conduit.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/otimDevnet.js
  var otimDevnet = /* @__PURE__ */ defineChain({
    id: 41144114,
    name: "Otim Devnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["http://devnet.otim.xyz"]
      }
    },
    contracts: {
      batchInvoker: {
        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palm.js
  var palm = /* @__PURE__ */ defineChain({
    id: 11297108109,
    name: "Palm",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/palmTestnet.js
  var palmTestnet = /* @__PURE__ */ defineChain({
    id: 11297108099,
    name: "Palm Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "PALM",
      symbol: "PALM"
    },
    rpcUrls: {
      default: {
        http: ["https://palm-mainnet.public.blastapi.io"],
        webSocket: ["wss://palm-mainnet.public.blastapi.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Chainlens",
        url: "https://palm.chainlens.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 15429248
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgn.js
  var sourceId29 = 1;
  var pgn = /* @__PURE__ */ defineChain({
    id: 424,
    network: "pgn",
    name: "PGN",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Explorer",
        url: "https://explorer.publicgoods.network",
        apiUrl: "https://explorer.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId29]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3380209
      },
      portal: {
        [sourceId29]: {
          address: "0xb26Fd985c5959bBB382BAFdD0b879E149e48116c"
        }
      },
      l1StandardBridge: {
        [sourceId29]: {
          address: "0xD0204B9527C1bA7bD765Fa5CCD9355d38338272b"
        }
      }
    },
    formatters: formatters2,
    sourceId: sourceId29
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pgnTestnet.js
  var sourceId30 = 11155111;
  var pgnTestnet = /* @__PURE__ */ defineChain({
    id: 58008,
    network: "pgn-testnet",
    name: "PGN ",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.publicgoods.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "PGN Testnet Explorer",
        url: "https://explorer.sepolia.publicgoods.network",
        apiUrl: "https://explorer.sepolia.publicgoods.network/api"
      }
    },
    contracts: {
      l2OutputOracle: {
        [sourceId30]: {
          address: "0xD5bAc3152ffC25318F848B3DD5dA6C85171BaEEe"
        }
      },
      portal: {
        [sourceId30]: {
          address: "0xF04BdD5353Bb0EFF6CA60CfcC78594278eBfE179"
        }
      },
      l1StandardBridge: {
        [sourceId30]: {
          address: "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3754925
      }
    },
    formatters: formatters2,
    sourceId: sourceId30,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/phoenix.js
  var phoenix = /* @__PURE__ */ defineChain({
    id: 13381,
    name: "Phoenix Blockchain",
    nativeCurrency: { name: "Phoenix", symbol: "PHX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.phoenixplorer.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Phoenixplorer",
        url: "https://phoenixplorer.com",
        apiUrl: "https://phoenixplorer.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x498cF757a575cFF2c2Ed9f532f56Efa797f86442",
        blockCreated: 5620192
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/playfiAlbireo.js
  var playfiAlbireo = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 1612127,
    name: "PlayFi Albireo Testnet",
    network: "albireo",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://albireo-rpc.playfi.ai"],
        webSocket: ["wss://albireo-rpc-ws.playfi.ai/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "PlayFi Albireo Explorer",
        url: "https://albireo-explorer.playfi.ai"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plinga.js
  var plinga = /* @__PURE__ */ defineChain({
    id: 242,
    name: "Plinga",
    nativeCurrency: { name: "Plinga", symbol: "PLINGA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpcurl.mainnet.plgchain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Plgscan",
        url: "https://www.plgscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0989576160f2e7092908BB9479631b901060b6e4",
        blockCreated: 204489
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/plumeTestnet.js
  var sourceId31 = 11155111;
  var plumeTestnet = /* @__PURE__ */ defineChain({
    id: 161221135,
    name: "Plume Testnet",
    nativeCurrency: {
      name: "Plume Sepolia Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.plumenetwork.xyz/http"],
        webSocket: ["wss://testnet-rpc.plumenetwork.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer.plumenetwork.xyz",
        apiUrl: "https://testnet-explorer.plumenetwork.xyz/api"
      }
    },
    testnet: true,
    sourceId: sourceId31
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygon.js
  var polygon = /* @__PURE__ */ defineChain({
    id: 137,
    name: "Polygon",
    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://polygon-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://polygonscan.com",
        apiUrl: "https://api.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonAmoy.js
  var polygonAmoy = /* @__PURE__ */ defineChain({
    id: 80002,
    name: "Polygon Amoy",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-amoy.polygon.technology"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://amoy.polygonscan.com",
        apiUrl: "https://api-amoy.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 3127388
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonMumbai.js
  var polygonMumbai = /* @__PURE__ */ defineChain({
    id: 80001,
    name: "Polygon Mumbai",
    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.ankr.com/polygon_mumbai"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://mumbai.polygonscan.com",
        apiUrl: "https://api-testnet.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 25770160
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvm.js
  var polygonZkEvm = /* @__PURE__ */ defineChain({
    id: 1101,
    name: "Polygon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://zkevm.polygonscan.com",
        apiUrl: "https://api-zkevm.polygonscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 57746
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmCardona.js
  var polygonZkEvmCardona = /* @__PURE__ */ defineChain({
    id: 2442,
    name: "Polygon zkEVM Cardona",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.cardona.zkevm-rpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://cardona-zkevm.polygonscan.com",
        apiUrl: "https://cardona-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 114091
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/polygonZkEvmTestnet.js
  var polygonZkEvmTestnet = /* @__PURE__ */ defineChain({
    id: 1442,
    name: "Polygon zkEVM Testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.public.zkevm-test.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "PolygonScan",
        url: "https://testnet-zkevm.polygonscan.com",
        apiUrl: "https://testnet-zkevm.polygonscan.com/api"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 525686
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechain.js
  var pulsechain = /* @__PURE__ */ defineChain({
    id: 369,
    name: "PulseChain",
    nativeCurrency: { name: "Pulse", symbol: "PLS", decimals: 18 },
    testnet: false,
    rpcUrls: {
      default: {
        http: ["https://rpc.pulsechain.com"],
        webSocket: ["wss://ws.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.pulsechain.com",
        apiUrl: "https://api.scan.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/pulsechainV4.js
  var pulsechainV4 = /* @__PURE__ */ defineChain({
    id: 943,
    name: "PulseChain V4",
    testnet: true,
    nativeCurrency: { name: "V4 Pulse", symbol: "v4PLS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.v4.testnet.pulsechain.com"],
        webSocket: ["wss://ws.v4.testnet.pulsechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "PulseScan",
        url: "https://scan.v4.testnet.pulsechain.com",
        apiUrl: "https://scan.v4.testnet.pulsechain.com/api"
      }
    },
    contracts: {
      ensRegistry: {
        address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14353601
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ql1.js
  var ql1 = /* @__PURE__ */ defineChain({
    id: 766,
    name: "QL1",
    nativeCurrency: {
      decimals: 18,
      name: "QOM",
      symbol: "QOM"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.qom.one"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ql1 Explorer",
        url: "https://scan.qom.one"
      }
    },
    contracts: {
      multicall3: {
        address: "0x7A52370716ea730585884F5BDB0f6E60C39b8C64"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qMainnet.js
  var qMainnet = /* @__PURE__ */ defineChain({
    id: 35441,
    name: "Q Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.q.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Mainnet Explorer",
        url: "https://explorer.q.org",
        apiUrl: "https://explorer.q.org/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/qTestnet.js
  var qTestnet = /* @__PURE__ */ defineChain({
    id: 35443,
    name: "Q Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Q",
      symbol: "Q"
    },
    rpcUrls: {
      default: { http: ["https://rpc.qtestnet.org"] }
    },
    blockExplorers: {
      default: {
        name: "Q Testnet Explorer",
        url: "https://explorer.qtestnet.org",
        apiUrl: "https://explorer.qtestnet.org/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/real.js
  var real = /* @__PURE__ */ defineChain({
    id: 111188,
    name: "re.al",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://real.drpc.org"] }
    },
    blockExplorers: {
      default: {
        name: "re.al Explorer",
        url: "https://explorer.re.al",
        apiUrl: "https://explorer.re.al/api/v2"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 695
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redbellyTestnet.js
  var redbellyTestnet = /* @__PURE__ */ defineChain({
    id: 153,
    name: "Redbelly Network Testnet",
    nativeCurrency: {
      name: "Redbelly Native Coin",
      symbol: "RBNT",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://governors.testnet.redbelly.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://explorer.testnet.redbelly.network",
        apiUrl: "https://ethernal.fly.dev/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/redstone.js
  var sourceId32 = 1;
  var redstone = defineChain({
    ...chainConfig2,
    name: "Redstone",
    id: 690,
    sourceId: sourceId32,
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.redstonechain.com"],
        webSocket: ["wss://rpc.redstonechain.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.redstone.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId32]: {
          address: "0xC7bCb0e8839a28A1cFadd1CF716de9016CdA51ae",
          blockCreated: 19578329
        }
      },
      l2OutputOracle: {
        [sourceId32]: {
          address: "0xa426A052f657AEEefc298b3B5c35a470e4739d69",
          blockCreated: 19578337
        }
      },
      l1StandardBridge: {
        [sourceId32]: {
          address: "0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69",
          blockCreated: 19578331
        }
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/reyaNetwork.js
  var reyaNetwork = /* @__PURE__ */ defineChain({
    id: 1729,
    name: "Reya Network",
    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
    rpcUrls: {
      default: {
        http: ["https://rpc.reya.network"],
        webSocket: ["wss://ws.reya.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Reya Network Explorer",
        url: "https://explorer.reya.network"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rollux.js
  var rollux = /* @__PURE__ */ defineChain({
    id: 570,
    name: "Rollux Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.rollux.com"],
        webSocket: ["wss://rpc.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxExplorer",
        url: "https://explorer.rollux.com",
        apiUrl: "https://explorer.rollux.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 119222
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rolluxTestnet.js
  var rolluxTestnet = /* @__PURE__ */ defineChain({
    id: 57e3,
    name: "Rollux Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc-tanenbaum.rollux.com/"],
        webSocket: ["wss://rpc-tanenbaum.rollux.com/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "RolluxTestnetExplorer",
        url: "https://rollux.tanenbaum.io",
        apiUrl: "https://rollux.tanenbaum.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1813675
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ronin.js
  var ronin = /* @__PURE__ */ defineChain({
    id: 2020,
    name: "Ronin",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ronin Explorer",
        url: "https://app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 26023535
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/root.js
  var root = /* @__PURE__ */ defineChain({
    id: 7668,
    name: "The Root Network",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://root.rootnet.live/archive"],
        webSocket: ["wss://root.rootnet.live/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 9218338
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootPorcini.js
  var rootPorcini = /* @__PURE__ */ defineChain({
    id: 7672,
    name: "The Root Network - Porcini",
    nativeCurrency: {
      decimals: 18,
      name: "XRP",
      symbol: "XRP"
    },
    rpcUrls: {
      default: {
        http: ["https://porcini.rootnet.app/archive"],
        webSocket: ["wss://porcini.rootnet.app/archive/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Rootscan",
        url: "https://porcini.rootscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xc9C2E2429AeC354916c476B30d729deDdC94988d",
        blockCreated: 10555692
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstock.js
  var rootstock = /* @__PURE__ */ defineChain({
    id: 30,
    name: "Rootstock Mainnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "RBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.rsk.co"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 4249540
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rootstockTestnet.js
  var rootstockTestnet = /* @__PURE__ */ defineChain({
    id: 31,
    name: "Rootstock Testnet",
    network: "rootstock",
    nativeCurrency: {
      decimals: 18,
      name: "Rootstock Bitcoin",
      symbol: "tRBTC"
    },
    rpcUrls: {
      default: { http: ["https://public-node.testnet.rsk.co"] }
    },
    blockExplorers: {
      default: {
        name: "RSK Explorer",
        url: "https://explorer.testnet.rootstock.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3.js
  var sourceId33 = 1;
  var rss3 = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 12553,
    name: "RSS3 VSL Mainnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Mainnet Scan",
        url: "https://scan.rss3.io",
        apiUrl: "https://scan.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId33]: {
          address: "0xE6f24d2C32B3109B18ed33cF08eFb490b1e09C10"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14193
      },
      portal: {
        [sourceId33]: {
          address: "0x6A12432491bbbE8d3babf75F759766774C778Db4",
          blockCreated: 19387057
        }
      },
      l1StandardBridge: {
        [sourceId33]: {
          address: "0x4cbab69108Aa72151EDa5A3c164eA86845f18438"
        }
      }
    },
    sourceId: sourceId33
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/rss3Sepolia.js
  var sourceId34 = 11155111;
  var rss3Sepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2331,
    name: "RSS3 VSL Sepolia Testnet",
    nativeCurrency: { name: "RSS3", symbol: "RSS3", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.rss3.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "RSS3 VSL Sepolia Testnet Scan",
        url: "https://scan.testnet.rss3.io",
        apiUrl: "https://scan.testnet.rss3.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId34]: {
          address: "0xDb5c46C3Eaa6Ed6aE8b2379785DF7dd029C0dC81"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 55697
      },
      portal: {
        [sourceId34]: {
          address: "0xcBD77E8E1E7F06B25baDe67142cdE82652Da7b57",
          blockCreated: 5345035
        }
      },
      l1StandardBridge: {
        [sourceId34]: {
          address: "0xdDD29bb63B0839FB1cE0eE439Ff027738595D07B"
        }
      }
    },
    testnet: true,
    sourceId: sourceId34
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/saigon.js
  var saigon = /* @__PURE__ */ defineChain({
    id: 2021,
    name: "Saigon Testnet",
    nativeCurrency: { name: "RON", symbol: "RON", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://saigon-testnet.roninchain.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Saigon Explorer",
        url: "https://saigon-app.roninchain.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 18736871
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sanko.js
  var sanko = /* @__PURE__ */ defineChain({
    id: 1996,
    name: "Sanko",
    nativeCurrency: { name: "DMT", symbol: "DMT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.sanko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sanko Explorer",
        url: "https://explorer.sanko.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphire.js
  var sapphire = /* @__PURE__ */ defineChain({
    id: 23294,
    name: "Oasis Sapphire",
    network: "sapphire",
    nativeCurrency: { name: "Sapphire Rose", symbol: "ROSE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sapphire.oasis.io"],
        webSocket: ["wss://sapphire.oasis.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/mainnet/sapphire"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 734531
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sapphireTestnet.js
  var sapphireTestnet = /* @__PURE__ */ defineChain({
    id: 23295,
    name: "Oasis Sapphire Testnet",
    network: "sapphire-testnet",
    nativeCurrency: { name: "Sapphire Test Rose", symbol: "TEST", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.sapphire.oasis.dev"],
        webSocket: ["wss://testnet.sapphire.oasis.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Oasis Explorer",
        url: "https://explorer.oasis.io/testnet/sapphire"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivm.js
  var satoshiVM = /* @__PURE__ */ defineChain({
    id: 3109,
    name: "SatoshiVM Alpha Mainnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://alpha-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://svmscan.io",
        apiUrl: "https://svmscan.io/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/satoshivmTestnet.js
  var satoshiVMTestnet = /* @__PURE__ */ defineChain({
    id: 3110,
    name: "SatoshiVM Testnet",
    nativeCurrency: {
      name: "BTC",
      symbol: "BTC",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://test-rpc-node-http.svmscan.io"] }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://testnet.svmscan.io",
        apiUrl: "https://testnet.svmscan.io/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scroll.js
  var scroll = /* @__PURE__ */ defineChain({
    id: 534352,
    name: "Scroll",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.scroll.io"],
        webSocket: ["wss://wss-rpc.scroll.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://scrollscan.com",
        apiUrl: "https://api.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 14
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/scrollSepolia.js
  var scrollSepolia = /* @__PURE__ */ defineChain({
    id: 534351,
    name: "Scroll Sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia-rpc.scroll.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Scrollscan",
        url: "https://sepolia.scrollscan.com",
        apiUrl: "https://api-sepolia.scrollscan.com/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 9473
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sei.js
  var sei = /* @__PURE__ */ defineChain({
    id: 1329,
    name: "Sei Network",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc.sei-apis.com/"],
        webSocket: ["wss://evm-ws.sei-apis.com/"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com",
        apiUrl: "https://seitrace.com/pacific-1/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiDevnet.js
  var seiDevnet = /* @__PURE__ */ defineChain({
    id: 713715,
    name: "Sei Devnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-arctic-1.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/seiTestnet.js
  var seiTestnet = /* @__PURE__ */ defineChain({
    id: 1328,
    name: "Sei Testnet",
    nativeCurrency: { name: "Sei", symbol: "SEI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evm-rpc-testnet.sei-apis.com"],
        webSocket: ["wss://evm-ws-testnet.sei-apis.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Seitrace",
        url: "https://seitrace.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sepolia.js
  var sepolia = /* @__PURE__ */ defineChain({
    id: 11155111,
    name: "Sepolia",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc2.sepolia.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia.etherscan.io",
        apiUrl: "https://api-sepolia.etherscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 751532
      },
      ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
      ensUniversalResolver: {
        address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
        blockCreated: 5317080
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shape.js
  var sourceId35 = 1;
  var shape = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 360,
    name: "Shape",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "shapescan",
        url: "https://shapescan.xyz",
        apiUrl: "https://shapescan.xyz/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId35]: {
          address: "0x6Ef8c69CfE4635d866e3E02732068022c06e724D",
          blockCreated: 20369940
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      },
      portal: {
        [sourceId35]: {
          address: "0xEB06fFa16011B5628BaB98E29776361c83741dd3",
          blockCreated: 20369933
        }
      },
      l1StandardBridge: {
        [sourceId35]: {
          address: "0x62Edd5f4930Ea92dCa3fB81689bDD9b9d076b57B",
          blockCreated: 20369935
        }
      }
    },
    sourceId: sourceId35
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shapeSepolia.js
  var sourceId36 = 11155111;
  var shapeSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 11011,
    name: "Shape Sepolia Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.shape.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer-sepolia.shape.network/",
        apiUrl: "https://explorer-sepolia.shape.network/api/v2"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId36
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shardeumSphinx.js
  var shardeumSphinx = /* @__PURE__ */ defineChain({
    id: 8082,
    name: "Shardeum Sphinx",
    nativeCurrency: { name: "SHARDEUM", symbol: "SHM", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sphinx.shardeum.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shardeum Explorer",
        url: "https://explorer-sphinx.shardeum.org"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibarium.js
  var shibarium = /* @__PURE__ */ defineChain({
    id: 109,
    name: "Shibarium",
    network: "shibarium",
    nativeCurrency: { name: "Bone", symbol: "BONE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.shibrpc.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://shibariumscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961",
        blockCreated: 265900
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shibariumTestnet.js
  var shibariumTestnet = /* @__PURE__ */ defineChain({
    id: 157,
    name: "Puppynet Shibarium",
    nativeCurrency: {
      decimals: 18,
      name: "Bone",
      symbol: "BONE"
    },
    rpcUrls: {
      default: { http: ["https://puppynet.shibrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://puppyscan.shib.io",
        apiUrl: "https://puppyscan.shib.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xA4029b74FBA366c926eDFA7Dd10B21C621170a4c",
        blockCreated: 3035769
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shiden.js
  var shiden = /* @__PURE__ */ defineChain({
    id: 336,
    name: "Shiden",
    nativeCurrency: {
      decimals: 18,
      name: "SDN",
      symbol: "SDN"
    },
    rpcUrls: {
      default: {
        http: ["https://shiden.public.blastapi.io"],
        webSocket: ["wss://shiden-rpc.dwellir.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shiden Scan",
        url: "https://shiden.subscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmer.js
  var shimmer = /* @__PURE__ */ defineChain({
    id: 148,
    name: "Shimmer",
    network: "shimmer",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.shimmer.network",
        apiUrl: "https://explorer.evm.shimmer.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/shimmerTestnet.js
  var shimmerTestnet = /* @__PURE__ */ defineChain({
    id: 1073,
    name: "Shimmer Testnet",
    network: "shimmer-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Shimmer",
      symbol: "SMR"
    },
    rpcUrls: {
      default: {
        http: ["https://json-rpc.evm.testnet.shimmer.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Shimmer Network Explorer",
        url: "https://explorer.evm.testnet.shimmer.network",
        apiUrl: "https://explorer.evm.testnet.shimmer.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/silicon.js
  var silicon = /* @__PURE__ */ defineChain({
    id: 2355,
    name: "Silicon zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.silicon.network",
          "https://silicon-mainnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconScope",
        url: "https://scope.silicon.network"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/siliconSepolia.js
  var siliconSepolia = /* @__PURE__ */ defineChain({
    id: 1722641160,
    name: "Silicon Sepolia zkEVM",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://rpc-sepolia.silicon.network",
          "https://silicon-testnet.nodeinfra.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SiliconSepoliaScope",
        url: "https://scope-sepolia.silicon.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/brawl.js
  var skaleBlockBrawlers = /* @__PURE__ */ defineChain({
    id: 391845894,
    name: "SKALE | Block Brawlers",
    nativeCurrency: { name: "BRAWL", symbol: "BRAWL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/frayed-decent-antares"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/frayed-decent-antares"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://frayed-decent-antares.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypso.js
  var skaleCalypso = /* @__PURE__ */ defineChain({
    id: 1564830818,
    name: "SKALE | Calypso NFT Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/honorable-steel-rasalhague"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/honorable-steel-rasalhague"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://honorable-steel-rasalhague.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3107626
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/calypsoTestnet.js
  var skaleCalypsoTestnet = /* @__PURE__ */ defineChain({
    id: 974399131,
    name: "SKALE Calypso Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/giant-half-dual-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/giant-half-dual-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://giant-half-dual-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 103220
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoBlades.js
  var skaleCryptoBlades = /* @__PURE__ */ defineChain({
    id: 1026062157,
    name: "SKALE | CryptoBlades",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/affectionate-immediate-pollux"],
        webSocket: [
          "wss://mainnet.skalenodes.com/v1/ws/affectionate-immediate-pollux"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://affectionate-immediate-pollux.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/cryptoColosseum.js
  var skaleCryptoColosseum = /* @__PURE__ */ defineChain({
    id: 1032942172,
    name: "SKALE | Crypto Colosseum",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/haunting-devoted-deneb"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/haunting-devoted-deneb"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://haunting-devoted-deneb.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europa.js
  var skaleEuropa = /* @__PURE__ */ defineChain({
    id: 2046399126,
    name: "SKALE | Europa Liquidity Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/elated-tan-skat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/elated-tan-skat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://elated-tan-skat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 3113495
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/europaTestnet.js
  var skaleEuropaTestnet = /* @__PURE__ */ defineChain({
    id: 1444673419,
    name: "SKALE Europa Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/juicy-low-small-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/juicy-low-small-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://juicy-low-small-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 110858
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/exorde.js
  var skaleExorde = /* @__PURE__ */ defineChain({
    id: 2139927552,
    name: "SKALE | Exorde",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/light-vast-diphda"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/light-vast-diphda"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://light-vast-diphda.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/humanProtocol.js
  var skaleHumanProtocol = /* @__PURE__ */ defineChain({
    id: 1273227453,
    name: "SKALE | Human Protocol",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/wan-red-ain"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/wan-red-ain"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://wan-red-ain.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebula.js
  var skaleNebula = /* @__PURE__ */ defineChain({
    id: 1482601649,
    name: "SKALE | Nebula Gaming Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/green-giddy-denebola"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/green-giddy-denebola"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://green-giddy-denebola.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2372986
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/nebulaTestnet.js
  var skaleNebulaTestnet = /* @__PURE__ */ defineChain({
    id: 37084624,
    name: "SKALE Nebula Testnet",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/lanky-ill-funny-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 105141
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/razor.js
  var skaleRazor = /* @__PURE__ */ defineChain({
    id: 278611351,
    name: "SKALE | Razor Network",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/turbulent-unique-scheat"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/turbulent-unique-scheat"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://turbulent-unique-scheat.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {}
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titan.js
  var skaleTitan = /* @__PURE__ */ defineChain({
    id: 1350216234,
    name: "SKALE | Titan Community Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.skalenodes.com/v1/parallel-stormy-spica"],
        webSocket: ["wss://mainnet.skalenodes.com/v1/ws/parallel-stormy-spica"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://parallel-stormy-spica.explorer.mainnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2076458
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/skale/titanTestnet.js
  var skaleTitanTestnet = /* @__PURE__ */ defineChain({
    id: 1020352220,
    name: "SKALE Titan Hub",
    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.skalenodes.com/v1/aware-fake-trim-testnet"],
        webSocket: ["wss://testnet.skalenodes.com/v1/ws/aware-fake-trim-testnet"]
      }
    },
    blockExplorers: {
      default: {
        name: "SKALE Explorer",
        url: "https://aware-fake-trim-testnet.explorer.testnet.skalenodes.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 104072
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sketchpad.js
  var sketchpad = /* @__PURE__ */ defineChain({
    id: 984123,
    name: "Forma Sketchpad",
    network: "sketchpad",
    nativeCurrency: {
      symbol: "TIA",
      name: "TIA",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.sketchpad-1.forma.art"],
        webSocket: ["wss://ws.sketchpad-1.forma.art"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sketchpad Explorer",
        url: "https://explorer.sketchpad-1.forma.art"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snax.js
  var sourceId37 = 1;
  var snax = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 2192,
    network: "snaxchain-mainnet",
    name: "SnaxChain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://explorer.snaxchain.io",
        apiUrl: "https://explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId37]: {
          address: "0x472562Fcf26D6b2793f8E0b0fB660ba0E5e08A46"
        }
      },
      l2OutputOracle: {
        [sourceId37]: {
          address: "0x2172e492Fc807F5d5645D0E3543f139ECF539294"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId37]: {
          address: "0x79f446D024d74D0Bb6E699C131c703463c5D65E9"
        }
      },
      l1StandardBridge: {
        [sourceId37]: {
          address: "0x6534Bdb6b5c060d3e6aa833433333135eFE8E0aA"
        }
      }
    },
    sourceId: sourceId37
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/snaxTestnet.js
  var sourceId38 = 11155111;
  var snaxTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 13001,
    network: "snaxchain-testnet",
    name: "SnaxChain Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet.snaxchain.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Snax Explorer",
        url: "https://testnet-explorer.snaxchain.io",
        apiUrl: "https://testnet-explorer.snaxchain.io/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId38]: {
          address: "0x206a75d89d45F146C54020F132FF93bEDD09f55E"
        }
      },
      l2OutputOracle: {
        [sourceId38]: {
          address: "0x60e3A368a4cdCEf85ffB964e372726F56A46221e"
        }
      },
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11"
      },
      portal: {
        [sourceId38]: {
          address: "0xb5afdd0E8dDF081Ef90e8A3e0c7b5798e66E954E"
        }
      },
      l1StandardBridge: {
        [sourceId38]: {
          address: "0xbd37E1a59D4C00C9A46F75018dffd84061bC5f74"
        }
      }
    },
    testnet: true,
    sourceId: sourceId38
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/soneiumMinato.js
  var sourceId39 = 11155111;
  var soneiumMinato = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1946,
    name: "Soneium Minato Testnet",
    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.minato.soneium.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer-testnet.soneium.org",
        apiUrl: "https://explorer-testnet.soneium.org/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      disputeGameFactory: {
        [sourceId39]: {
          address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6"
        }
      },
      l2OutputOracle: {
        [sourceId39]: {
          address: "0x710e5286C746eC38beeB7538d0146f60D27be343"
        }
      },
      portal: {
        [sourceId39]: {
          address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3",
          blockCreated: 6466136
        }
      },
      l1StandardBridge: {
        [sourceId39]: {
          address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2",
          blockCreated: 6466136
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1
      }
    },
    testnet: true,
    sourceId: sourceId39
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbird.js
  var songbird = /* @__PURE__ */ defineChain({
    id: 19,
    name: "Songbird Canary-Network",
    nativeCurrency: {
      decimals: 18,
      name: "Songbird",
      symbol: "SGB"
    },
    rpcUrls: {
      default: { http: ["https://songbird-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Songbird Explorer",
        url: "https://songbird-explorer.flare.network",
        apiUrl: "https://songbird-explorer.flare.network/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/songbirdTestnet.js
  var songbirdTestnet = /* @__PURE__ */ defineChain({
    id: 16,
    name: "Songbird Testnet Coston",
    nativeCurrency: {
      decimals: 18,
      name: "Coston Flare",
      symbol: "CFLR"
    },
    rpcUrls: {
      default: { http: ["https://coston-api.flare.network/ext/C/rpc"] }
    },
    blockExplorers: {
      default: {
        name: "Coston Explorer",
        url: "https://coston-explorer.flare.network",
        apiUrl: "https://coston-explorer.flare.network/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/sophonTestnet.js
  var sophonTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 531050104,
    name: "Sophon Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Sophon",
      symbol: "SOPH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.sophon.xyz"],
        webSocket: ["wss://rpc.testnet.sophon.xyz/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Sophon Block Explorer",
        url: "https://explorer.testnet.sophon.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0x83c04d112adedA2C6D9037bb6ecb42E7f0b108Af",
        blockCreated: 15642
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/spicy.js
  var spicy = /* @__PURE__ */ defineChain({
    id: 88882,
    name: "Chiliz Spicy Testnet",
    network: "chiliz-spicy-Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "CHZ",
      symbol: "CHZ"
    },
    rpcUrls: {
      default: {
        http: [
          "https://spicy-rpc.chiliz.com",
          "https://chiliz-spicy-rpc.publicnode.com"
        ],
        webSocket: [
          "wss://spicy-rpc-ws.chiliz.com",
          "wss://chiliz-spicy-rpc.publicnode.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Chiliz Explorer",
        url: "http://spicy-explorer.chiliz.com",
        apiUrl: "http://spicy-explorer.chiliz.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/step.js
  var step = /* @__PURE__ */ defineChain({
    id: 1234,
    name: "Step Network",
    nativeCurrency: { name: "FITFI", symbol: "FITFI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.step.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "Step Scan",
        url: "https://stepscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/storyTestnet.js
  var storyTestnet = /* @__PURE__ */ defineChain({
    id: 1513,
    name: "Story Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "IP",
      symbol: "IP"
    },
    rpcUrls: {
      default: { http: ["https://testnet.storyrpc.io"] }
    },
    blockExplorers: {
      default: {
        name: "Story Testnet Explorer",
        url: "https://testnet.storyscan.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/stratis.js
  var stratis = /* @__PURE__ */ defineChain({
    id: 105105,
    name: "Stratis Mainnet",
    network: "stratis",
    nativeCurrency: {
      name: "Stratis",
      symbol: "STRAX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.stratisevm.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Stratis Explorer",
        url: "https://explorer.stratisevm.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superlumio.js
  var superlumio = /* @__PURE__ */ defineChain({
    id: 8866,
    name: "SuperLumio",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.lumio.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Lumio explorer",
        url: "https://explorer.lumio.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/superposition.js
  var superposition = /* @__PURE__ */ defineChain({
    id: 55244,
    name: "Superposition",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.superposition.so"] }
    },
    blockExplorers: {
      default: {
        name: "Superposition Explorer",
        url: "https://explorer.superposition.so"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swan.js
  var swan = /* @__PURE__ */ defineChain({
    id: 254,
    name: "Swan Chain Mainnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://mainnet-rpc.swanchain.org"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://swanscan.io"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanProximaTestnet.js
  var swanProximaTestnet = /* @__PURE__ */ defineChain({
    id: 20241133,
    name: "Swan Proxima Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc-proxima.swanchain.io	"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://proxima-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/swanSaturnTestnet.js
  var swanSaturnTestnet = /* @__PURE__ */ defineChain({
    id: 2024,
    name: "Swan Saturn Testnet",
    nativeCurrency: { name: "Swan Ether", symbol: "sETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://saturn-rpc.swanchain.io"] }
    },
    blockExplorers: {
      default: {
        name: "Swan Explorer",
        url: "https://saturn-explorer.swanchain.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoin.js
  var syscoin = /* @__PURE__ */ defineChain({
    id: 57,
    name: "Syscoin Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.syscoin.org"],
        webSocket: ["wss://rpc.syscoin.org/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinExplorer",
        url: "https://explorer.syscoin.org",
        apiUrl: "https://explorer.syscoin.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 287139
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/syscoinTestnet.js
  var syscoinTestnet = /* @__PURE__ */ defineChain({
    id: 5700,
    name: "Syscoin Tanenbaum Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Syscoin",
      symbol: "SYS"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.tanenbaum.io"],
        webSocket: ["wss://rpc.tanenbaum.io/wss"]
      }
    },
    blockExplorers: {
      default: {
        name: "SyscoinTestnetExplorer",
        url: "https://tanenbaum.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 271288
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taiko.js
  var taiko = /* @__PURE__ */ defineChain({
    id: 167e3,
    name: "Taiko Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taiko.xyz"],
        webSocket: ["wss://ws.mainnet.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://taikoscan.io",
        apiUrl: "https://api.taikoscan.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoHekla.js
  var taikoHekla = /* @__PURE__ */ defineChain({
    id: 167009,
    name: "Taiko Hekla L2",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.hekla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taikoscan",
        url: "https://hekla.taikoscan.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoJolnir.js
  var taikoJolnir = /* @__PURE__ */ defineChain({
    id: 167007,
    name: "Taiko Jolnir (Alpha-5 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.jolnir.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.jolnir.taiko.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 732706
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoKatla.js
  var taikoKatla = /* @__PURE__ */ defineChain({
    id: 167008,
    name: "Taiko Katla (Alpha-6 Testnet)",
    network: "tko-katla",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.katla.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.katla.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taikoTestnetSepolia.js
  var taikoTestnetSepolia = /* @__PURE__ */ defineChain({
    id: 167005,
    name: "Taiko (Alpha-3 Testnet)",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.test.taiko.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "blockscout",
        url: "https://explorer.test.taiko.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxa.js
  var taraxa = /* @__PURE__ */ defineChain({
    id: 841,
    name: "Taraxa Mainnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.mainnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.mainnet.taraxa.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/taraxaTestnet.js
  var taraxaTestnet = /* @__PURE__ */ defineChain({
    id: 842,
    name: "Taraxa Testnet",
    nativeCurrency: { name: "Tara", symbol: "TARA", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.taraxa.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Taraxa Explorer",
        url: "https://explorer.testnet.taraxa.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telcoinTestnet.js
  var telcoinTestnet = /* @__PURE__ */ defineChain({
    id: 2017,
    name: "Telcoin Adiri Testnet",
    nativeCurrency: { name: "Telcoin", symbol: "TEL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.telcoin.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "telscan",
        url: "https://telscan.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telos.js
  var telos = /* @__PURE__ */ defineChain({
    id: 40,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://mainnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan",
        url: "https://www.teloscan.io/"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 246530709
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/telosTestnet.js
  var telosTestnet = /* @__PURE__ */ defineChain({
    id: 41,
    name: "Telos",
    nativeCurrency: {
      decimals: 18,
      name: "Telos",
      symbol: "TLOS"
    },
    rpcUrls: {
      default: { http: ["https://testnet.telos.net/evm"] }
    },
    blockExplorers: {
      default: {
        name: "Teloscan (testnet)",
        url: "https://testnet.teloscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tenet.js
  var tenet = /* @__PURE__ */ defineChain({
    id: 1559,
    name: "Tenet",
    network: "tenet-mainnet",
    nativeCurrency: {
      name: "TENET",
      symbol: "TENET",
      decimals: 18
    },
    rpcUrls: {
      default: { http: ["https://rpc.tenet.org"] }
    },
    blockExplorers: {
      default: {
        name: "TenetScan Mainnet",
        url: "https://tenetscan.io",
        apiUrl: "https://tenetscan.io/api"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thaiChain.js
  var thaiChain = /* @__PURE__ */ defineChain({
    id: 7,
    name: "ThaiChain",
    nativeCurrency: { name: "TCH", symbol: "TCH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.thaichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://exp.thaichain.org",
        apiUrl: "https://exp.thaichain.org/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0DaD6130e832c21719C5CE3bae93454E16A84826",
        blockCreated: 4806386
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderCore.js
  var thunderCore = /* @__PURE__ */ defineChain({
    id: 108,
    name: "ThunderCore Mainnet",
    nativeCurrency: { name: "TT", symbol: "TT", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet-rpc.thundercore.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "ThunderCore Explorer",
        url: "https://viewblock.io/thundercore"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/thunderTestnet.js
  var thunderTestnet = /* @__PURE__ */ defineChain({
    id: 997,
    name: "5ireChain Thunder Testnet",
    nativeCurrency: { name: "5ire Token", symbol: "5IRE", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.5ire.network"]
      }
    },
    blockExplorers: {
      default: {
        name: "5ireChain Explorer",
        url: "https://explorer.5ire.network"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tiktrixTestnet.js
  var tiktrixTestnet = /* @__PURE__ */ defineChain({
    id: 62092,
    name: "TikTrix Testnet",
    nativeCurrency: {
      name: "tTTX",
      symbol: "tTTX",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://tiktrix-rpc.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "TikTrix Testnet Explorer",
        url: "https://tiktrix.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/tron.js
  var tron = /* @__PURE__ */ defineChain({
    id: 728126428,
    name: "Tron",
    nativeCurrency: { name: "TRON", symbol: "TRX", decimals: 6 },
    rpcUrls: {
      default: {
        http: ["https://api.trongrid.io/jsonrpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Tronscan",
        url: "https://tronscan.org",
        apiUrl: "https://apilist.tronscanapi.com/api"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultron.js
  var ultron = /* @__PURE__ */ defineChain({
    id: 1231,
    name: "Ultron Mainnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-rpc.net"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://ulxscan.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/ultronTestnet.js
  var ultronTestnet = /* @__PURE__ */ defineChain({
    id: 1230,
    name: "Ultron Testnet",
    nativeCurrency: { name: "ULX", symbol: "ULX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://ultron-dev.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ultron Scan",
        url: "https://explorer.ultron-dev.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unichainSepolia.js
  var sourceId40 = 11155111;
  var unichainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 1301,
    name: "Unichain Sepolia",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.unichain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Uniscan",
        url: "https://sepolia.uniscan.xyz",
        apiUrl: "https://api-sepolia.uniscan.xyz"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      portal: {
        [sourceId40]: {
          address: "0x0d83dab629f0e0F9d36c0Cbc89B69a489f0751bD"
        }
      },
      l1StandardBridge: {
        [sourceId40]: {
          address: "0xea58fcA6849d79EAd1f26608855c2D6407d54Ce2"
        }
      },
      disputeGameFactory: {
        [sourceId40]: {
          address: "0xeff73e5aa3B9AEC32c659Aa3E00444d20a84394b"
        }
      }
    },
    testnet: true,
    sourceId: sourceId40
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unique.js
  var unique = /* @__PURE__ */ defineChain({
    id: 8880,
    name: "Unique Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "UNQ",
      symbol: "UNQ"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Unique Subscan",
        url: "https://unique.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueOpal.js
  var uniqueOpal = /* @__PURE__ */ defineChain({
    id: 8882,
    name: "Opal Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OPL",
      symbol: "OPL"
    },
    rpcUrls: {
      default: { http: ["https://rpc-opal.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Opal Subscan",
        url: "https://opal.subscan.io/"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/uniqueQuartz.js
  var uniqueQuartz = /* @__PURE__ */ defineChain({
    id: 8881,
    name: "Quartz Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "QTZ",
      symbol: "QTZ"
    },
    rpcUrls: {
      default: { http: ["https://rpc-quartz.unique.network"] }
    },
    blockExplorers: {
      default: {
        name: "Quartz Subscan",
        url: "https://quartz.subscan.io/"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/unreal.js
  var unreal = /* @__PURE__ */ defineChain({
    id: 18233,
    name: "Unreal",
    nativeCurrency: {
      name: "reETH",
      decimals: 18,
      symbol: "reETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.unreal-orbit.gelato.digital"] }
    },
    blockExplorers: {
      default: {
        name: "Unreal Explorer",
        url: "https://unreal.blockscout.com",
        apiUrl: "https://unreal.blockscout.com/api/v2"
      }
    },
    testnet: true,
    contracts: {
      multicall3: {
        address: "0x8b6B0e60D8CD84898Ea8b981065A12F876eA5677",
        blockCreated: 1745
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vechain.js
  var vechain = /* @__PURE__ */ defineChain({
    id: 100009,
    name: "Vechain",
    nativeCurrency: { name: "VeChain", symbol: "VET", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://mainnet.vechain.org"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vechain Explorer",
        url: "https://explore.vechain.org"
      },
      vechainStats: {
        name: "Vechain Stats",
        url: "https://vechainstats.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/velas.js
  var velas = /* @__PURE__ */ defineChain({
    id: 106,
    name: "Velas EVM Mainnet",
    nativeCurrency: { name: "VLX", symbol: "VLX", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://evmexplorer.velas.com/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Velas Explorer",
        url: "https://evmexplorer.velas.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/viction.js
  var viction = /* @__PURE__ */ defineChain({
    id: 88,
    name: "Viction",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://vicscan.xyz"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/victionTestnet.js
  var victionTestnet = /* @__PURE__ */ defineChain({
    id: 89,
    name: "Viction Testnet",
    nativeCurrency: { name: "Viction", symbol: "VIC", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc-testnet.viction.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "VIC Scan",
        url: "https://testnet.vicscan.xyz"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 12170179
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/vision.js
  var vision = /* @__PURE__ */ defineChain({
    id: 888888,
    name: "Vision",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/visionTestnet.js
  var visionTestnet = /* @__PURE__ */ defineChain({
    id: 666666,
    name: "Vision Testnet",
    nativeCurrency: { name: "VISION", symbol: "VS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://vpioneer.infragrid.v.network/ethereum/compatible"]
      }
    },
    blockExplorers: {
      default: {
        name: "Vision Scan",
        url: "https://visionscan.org/?chain=vpioneer"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchain.js
  var wanchain = /* @__PURE__ */ defineChain({
    id: 888,
    name: "Wanchain",
    nativeCurrency: { name: "WANCHAIN", symbol: "WAN", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://gwan-ssl.wandevs.org:56891",
          "https://gwan2-ssl.wandevs.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScan",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcDF6A1566e78EB4594c86Fe73Fcdc82429e97fbB",
        blockCreated: 25312390
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wanchainTestnet.js
  var wanchainTestnet = /* @__PURE__ */ defineChain({
    id: 999,
    name: "Wanchain Testnet",
    nativeCurrency: { name: "WANCHAIN", symbol: "WANt", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://gwan-ssl.wandevs.org:46891"]
      }
    },
    blockExplorers: {
      default: {
        name: "WanScanTest",
        url: "https://wanscan.org"
      }
    },
    contracts: {
      multicall3: {
        address: "0x11c89bF4496c39FB80535Ffb4c92715839CC5324",
        blockCreated: 24743448
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/weavevmAlphanet.js
  var weaveVMAlphanet = /* @__PURE__ */ defineChain({
    id: 9496,
    name: "WeaveVM Alphanet",
    nativeCurrency: { name: "Testnet WeaveVM", symbol: "tWVM", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://testnet-rpc.wvm.dev"] }
    },
    blockExplorers: {
      default: {
        name: "WeaveVM Alphanet Explorer",
        url: "https://explorer.wvm.dev"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemix.js
  var wemix = /* @__PURE__ */ defineChain({
    id: 1111,
    name: "WEMIX",
    network: "wemix-mainnet",
    nativeCurrency: { name: "WEMIX", symbol: "WEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://explorer.wemix.com"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/wemixTestnet.js
  var wemixTestnet = /* @__PURE__ */ defineChain({
    id: 1112,
    name: "WEMIX Testnet",
    network: "wemix-testnet",
    nativeCurrency: { name: "WEMIX", symbol: "tWEMIX", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://api.test.wemix.com"] }
    },
    blockExplorers: {
      default: {
        name: "wemixExplorer",
        url: "https://testnet.wemixscan.com",
        apiUrl: "https://testnet.wemixscan.com/api"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchain.js
  var sourceId41 = 1;
  var worldchain = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 480,
    name: "World Chain",
    network: "worldchain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-mainnet.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan",
        url: "https://worldscan.org",
        apiUrl: "https://api.worldscan.org/api"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-mainnet.explorer.alchemy.com",
        apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId41]: {
          address: "0x0E90dCAFBC242D2C861A20Bb20EC8E7182965a52"
        }
      },
      l2OutputOracle: {
        [sourceId41]: {
          address: "0x19A6d1E9034596196295CF148509796978343c5D"
        }
      },
      portal: {
        [sourceId41]: {
          address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C"
        }
      },
      l1StandardBridge: {
        [sourceId41]: {
          address: "0x470458C91978D2d929704489Ad730DC3E3001113"
        }
      }
    },
    testnet: false,
    sourceId: sourceId41
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/worldchainSepolia.js
  var sourceId42 = 11155111;
  var worldchainSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 4801,
    name: "World Chain Sepolia",
    network: "worldchain-sepolia",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] },
      public: { http: ["https://worldchain-sepolia.g.alchemy.com/public"] }
    },
    blockExplorers: {
      default: {
        name: "Worldscan Sepolia",
        url: "https://sepolia.worldscan.org"
      },
      blockscout: {
        name: "Blockscout",
        url: "https://worldchain-sepolia.explorer.alchemy.com",
        apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 0
      },
      disputeGameFactory: {
        [sourceId42]: {
          address: "0x8cF97Ee616C986a070F5020d973b456D0120C253"
        }
      },
      l2OutputOracle: {
        [sourceId42]: {
          address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e"
        }
      },
      portal: {
        [sourceId42]: {
          address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4"
        }
      },
      l1StandardBridge: {
        [sourceId42]: {
          address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE"
        }
      }
    },
    testnet: true,
    sourceId: sourceId42
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xai.js
  var xai = /* @__PURE__ */ defineChain({
    id: 660279,
    name: "Xai Mainnet",
    nativeCurrency: { name: "Xai", symbol: "XAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://explorer.xai-chain.net"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 222549
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xaiTestnet.js
  var xaiTestnet = /* @__PURE__ */ defineChain({
    id: 37714555429,
    name: "Xai Testnet",
    nativeCurrency: { name: "sXai", symbol: "sXAI", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://testnet-v2.xai-chain.net/rpc"]
      }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://testnet-explorer-v2.xai-chain.net"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdc.js
  var xdc = /* @__PURE__ */ defineChain({
    id: 50,
    name: "XinFin Network",
    nativeCurrency: {
      decimals: 18,
      name: "XDC",
      symbol: "XDC"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xdcrpc.com"] }
    },
    blockExplorers: {
      default: {
        name: "XDCScan",
        url: "https://xdcscan.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0x0B1795ccA8E4eC4df02346a082df54D437F8D9aF",
        blockCreated: 75884020
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xdcTestnet.js
  var xdcTestnet = /* @__PURE__ */ defineChain({
    id: 51,
    name: "Apothem Network",
    nativeCurrency: {
      decimals: 18,
      name: "TXDC",
      symbol: "TXDC"
    },
    rpcUrls: {
      default: { http: ["https://erpc.apothem.network"] }
    },
    blockExplorers: {
      default: {
        name: "Blocksscan",
        url: "https://apothem.blocksscan.io"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 59765389
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayer.js
  var xLayer = /* @__PURE__ */ defineChain({
    id: 196,
    name: "X Layer Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://rpc.xlayer.tech"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer",
        apiUrl: "https://www.oklink.com/api/v5/explorer/xlayer/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 47416
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xLayerTestnet.js
  var xLayerTestnet = /* @__PURE__ */ defineChain({
    id: 195,
    name: "X1 Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "OKB",
      symbol: "OKB"
    },
    rpcUrls: {
      default: { http: ["https://xlayertestrpc.okx.com"] }
    },
    blockExplorers: {
      default: {
        name: "OKLink",
        url: "https://www.oklink.com/xlayer-test"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 624344
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/xrSepolia.js
  var xrSepolia = /* @__PURE__ */ defineChain({
    id: 2730,
    name: "XR Sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "tXR",
      symbol: "tXR"
    },
    rpcUrls: {
      default: { http: ["https://xr-sepolia-testnet.rpc.caldera.xyz/http"] }
    },
    blockExplorers: {
      default: {
        name: "Blockscout",
        url: "https://xr-sepolia-testnet.explorer.caldera.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerse.js
  var yooldoVerse = /* @__PURE__ */ defineChain({
    id: 50005,
    name: "Yooldo Verse",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Explorer",
        url: "https://explorer.yooldo-verse.xyz"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/yooldoVerseTestnet.js
  var yooldoVerseTestnet = /* @__PURE__ */ defineChain({
    id: 50006,
    name: "Yooldo Verse Testnet",
    nativeCurrency: { name: "OAS", symbol: "OAS", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.testnet.yooldo-verse.xyz"]
      }
    },
    blockExplorers: {
      default: {
        name: "Yooldo Verse Testnet Explorer",
        url: "https://explorer.testnet.yooldo-verse.xyz"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zenchainTestnet.js
  var zenchainTestnet = /* @__PURE__ */ defineChain({
    id: 8408,
    name: "Zenchain Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ZCX",
      symbol: "ZCX"
    },
    rpcUrls: {
      default: {
        http: ["https://zenchain-testnet.api.onfinality.io/public"],
        webSocket: ["wss://zenchain-testnet.api.onfinality.io/public-ws"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 230019
      }
    },
    blockExplorers: {
      default: {
        name: "Zentrace",
        url: "https://zentrace.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachain.js
  var zetachain = /* @__PURE__ */ defineChain({
    id: 7e3,
    name: "ZetaChain",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "ZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 1632781
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://explorer.zetachain.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zetachainAthensTestnet.js
  var zetachainAthensTestnet = /* @__PURE__ */ defineChain({
    id: 7001,
    name: "ZetaChain Athens Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zeta",
      symbol: "aZETA"
    },
    rpcUrls: {
      default: {
        http: ["https://zetachain-athens-evm.blockpi.network/v1/rpc/public"]
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 2715217
      }
    },
    blockExplorers: {
      default: {
        name: "ZetaScan",
        url: "https://athens.explorer.zetachain.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zhejiang.js
  var zhejiang = /* @__PURE__ */ defineChain({
    id: 1337803,
    name: "Zhejiang",
    nativeCurrency: { name: "Zhejiang Ether", symbol: "ZhejETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://rpc.zhejiang.ethpandaops.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "Beaconchain",
        url: "https://zhejiang.beaconcha.in"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqa.js
  var zilliqa = /* @__PURE__ */ defineChain({
    id: 32769,
    name: "Zilliqa",
    network: "zilliqa",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.zilliqa.com"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zilliqaTestnet.js
  var zilliqaTestnet = /* @__PURE__ */ defineChain({
    id: 33101,
    name: "Zilliqa Testnet",
    network: "zilliqa-testnet",
    nativeCurrency: { name: "Zilliqa", symbol: "ZIL", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://dev-api.zilliqa.com"]
      }
    },
    blockExplorers: {
      default: {
        name: "Ethernal",
        url: "https://evmx.testnet.zilliqa.com"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuit.js
  var zircuit = /* @__PURE__ */ defineChain({
    id: 48900,
    name: "Zircuit Mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-mainnet.p2pify.com",
          "https://zircuit1-mainnet.liquify.com",
          "https://zircuit-mainnet.drpc.org"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Explorer",
        url: "https://explorer.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zircuitTestnet.js
  var zircuitTestnet = /* @__PURE__ */ defineChain({
    id: 48899,
    name: "Zircuit Testnet",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: [
          "https://zircuit1-testnet.p2pify.com",
          "https://zircuit1-testnet.liquify.com"
        ]
      }
    },
    blockExplorers: {
      default: {
        name: "Zircuit Testnet Explorer",
        url: "https://explorer.testnet.zircuit.com"
      }
    },
    contracts: {
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 6040287
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFair.js
  var zkFair = /* @__PURE__ */ defineChain({
    id: 42766,
    name: "ZKFair Mainnet",
    network: "zkfair-mainnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://scan.zkfair.io",
        apiUrl: "https://scan.zkfair.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xca11bde05977b3631167028862be2a173976ca11",
        blockCreated: 6090959
      }
    },
    testnet: false
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkFairTestnet.js
  var zkFairTestnet = /* @__PURE__ */ defineChain({
    id: 43851,
    name: "ZKFair Testnet",
    network: "zkfair-testnet",
    nativeCurrency: {
      decimals: 18,
      name: "USD Coin",
      symbol: "USDC"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet-rpc.zkfair.io"]
      }
    },
    blockExplorers: {
      default: {
        name: "zkFair Explorer",
        url: "https://testnet-scan.zkfair.io"
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNova.js
  var zkLinkNova = /* @__PURE__ */ defineChain({
    id: 810180,
    name: "zkLink Nova",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zkLinkNovaSepoliaTestnet.js
  var zkLinkNovaSepoliaTestnet = /* @__PURE__ */ defineChain({
    id: 810181,
    name: "zkLink Nova Sepolia Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "ETH",
      symbol: "ETH"
    },
    rpcUrls: {
      default: { http: ["https://sepolia.rpc.zklink.io"] }
    },
    blockExplorers: {
      default: {
        name: "zkLink Nova Block Explorer",
        url: "https://sepolia.explorer.zklink.io"
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksync.js
  var zksync = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 324,
    name: "ZKsync Era",
    network: "zksync-era",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://mainnet.era.zksync.io"],
        webSocket: ["wss://mainnet.era.zksync.io/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://era.zksync.network/",
        apiUrl: "https://api-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://explorer.zksync.io/",
        apiUrl: "https://block-explorer-api.mainnet.zksync.io/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 45659388
      }
    }
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncInMemoryNode.js
  var zksyncInMemoryNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 260,
    name: "ZKsync InMemory Node",
    network: "zksync-in-memory-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:8011"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncLocalNode.js
  var zksyncLocalNode = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 270,
    name: "ZKsync CLI Local Node",
    network: "zksync-cli-local-node",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["http://localhost:3050"]
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zksyncSepoliaTestnet.js
  var zksyncSepoliaTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig,
    id: 300,
    name: "ZKsync Sepolia Testnet",
    network: "zksync-sepolia-testnet",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: {
        http: ["https://sepolia.era.zksync.dev"],
        webSocket: ["wss://sepolia.era.zksync.dev/ws"]
      }
    },
    blockExplorers: {
      default: {
        name: "Etherscan",
        url: "https://sepolia-era.zksync.network/",
        apiUrl: "https://api-sepolia-era.zksync.network/api"
      },
      native: {
        name: "ZKsync Explorer",
        url: "https://sepolia.explorer.zksync.io/",
        blockExplorerApi: "https://block-explorer-api.sepolia.zksync.dev/api"
      }
    },
    contracts: {
      multicall3: {
        address: "0xF9cda624FBC7e059355ce98a31693d299FACd963"
      },
      universalSignatureVerifier: {
        address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C",
        blockCreated: 3855712
      }
    },
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zora.js
  var sourceId43 = 1;
  var zora = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 7777777,
    name: "Zora",
    nativeCurrency: {
      decimals: 18,
      name: "Ether",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://rpc.zora.energy"],
        webSocket: ["wss://rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://explorer.zora.energy",
        apiUrl: "https://explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId43]: {
          address: "0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 5882
      },
      portal: {
        [sourceId43]: {
          address: "0x1a0ad011913A150f69f6A19DF447A0CfD9551054"
        }
      },
      l1StandardBridge: {
        [sourceId43]: {
          address: "0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"
        }
      }
    },
    sourceId: sourceId43
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraSepolia.js
  var sourceId44 = 11155111;
  var zoraSepolia = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999999999,
    name: "Zora Sepolia",
    network: "zora-sepolia",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Sepolia",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://sepolia.rpc.zora.energy"],
        webSocket: ["wss://sepolia.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Zora Sepolia Explorer",
        url: "https://sepolia.explorer.zora.energy/",
        apiUrl: "https://sepolia.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      l2OutputOracle: {
        [sourceId44]: {
          address: "0x2615B481Bd3E5A1C0C7Ca3Da1bdc663E8615Ade9"
        }
      },
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 83160
      },
      portal: {
        [sourceId44]: {
          address: "0xeffE2C6cA9Ab797D418f0D91eA60807713f3536f"
        }
      },
      l1StandardBridge: {
        [sourceId44]: {
          address: "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB"
        }
      }
    },
    sourceId: sourceId44,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/chains/definitions/zoraTestnet.js
  var sourceId45 = 5;
  var zoraTestnet = /* @__PURE__ */ defineChain({
    ...chainConfig2,
    id: 999,
    name: "Zora Goerli Testnet",
    nativeCurrency: {
      decimals: 18,
      name: "Zora Goerli",
      symbol: "ETH"
    },
    rpcUrls: {
      default: {
        http: ["https://testnet.rpc.zora.energy"],
        webSocket: ["wss://testnet.rpc.zora.energy"]
      }
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url: "https://testnet.explorer.zora.energy",
        apiUrl: "https://testnet.explorer.zora.energy/api"
      }
    },
    contracts: {
      ...chainConfig2.contracts,
      multicall3: {
        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
        blockCreated: 189123
      },
      portal: {
        [sourceId45]: {
          address: "0xDb9F51790365e7dc196e7D072728df39Be958ACe"
        }
      }
    },
    sourceId: sourceId45,
    testnet: true
  });

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  init_secp256k1();
  init_toHex();

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/toAccount.js
  init_address();
  init_isAddress();
  function toAccount(source) {
    if (typeof source === "string") {
      if (!isAddress(source, { strict: false }))
        throw new InvalidAddressError({ address: source });
      return {
        address: source,
        type: "json-rpc"
      };
    }
    if (!isAddress(source.address, { strict: false }))
      throw new InvalidAddressError({ address: source.address });
    return {
      address: source.address,
      nonceManager: source.nonceManager,
      sign: source.sign,
      experimental_signAuthorization: source.experimental_signAuthorization,
      signMessage: source.signMessage,
      signTransaction: source.signTransaction,
      signTypedData: source.signTypedData,
      source: "custom",
      type: "local"
    };
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/sign.js
  init_secp256k1();
  init_toHex();
  async function sign({ hash: hash3, privateKey, to = "object" }) {
    const { r, s, recovery } = secp256k1.sign(hash3.slice(2), privateKey.slice(2));
    const signature = {
      r: numberToHex(r, { size: 32 }),
      s: numberToHex(s, { size: 32 }),
      v: recovery ? 28n : 27n,
      yParity: recovery
    };
    return (() => {
      if (to === "bytes" || to === "hex")
        return serializeSignature({ ...signature, to });
      return signature;
    })();
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signAuthorization.js
  async function experimental_signAuthorization(parameters) {
    const { contractAddress, chainId, nonce, privateKey, to = "object" } = parameters;
    const signature = await sign({
      hash: hashAuthorization({ contractAddress, chainId, nonce }),
      privateKey,
      to
    });
    if (to === "object")
      return {
        contractAddress,
        chainId,
        nonce,
        ...signature
      };
    return signature;
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signMessage.js
  async function signMessage2({ message, privateKey }) {
    return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTransaction.js
  init_keccak256();
  async function signTransaction2(parameters) {
    const { privateKey, transaction, serializer = serializeTransaction } = parameters;
    const signableTransaction = (() => {
      if (transaction.type === "eip4844")
        return {
          ...transaction,
          sidecars: false
        };
      return transaction;
    })();
    const signature = await sign({
      hash: keccak256(serializer(signableTransaction)),
      privateKey
    });
    return serializer(transaction, signature);
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/utils/signTypedData.js
  async function signTypedData2(parameters) {
    const { privateKey, ...typedData } = parameters;
    return await sign({
      hash: hashTypedData(typedData),
      privateKey,
      to: "hex"
    });
  }

  // node_modules/.deno/viem@2.21.35/node_modules/viem/_esm/accounts/privateKeyToAccount.js
  function privateKeyToAccount(privateKey, options = {}) {
    const { nonceManager: nonceManager2 } = options;
    const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
    const address = publicKeyToAddress(publicKey);
    const account = toAccount({
      address,
      nonceManager: nonceManager2,
      async sign({ hash: hash3 }) {
        return sign({ hash: hash3, privateKey, to: "hex" });
      },
      async experimental_signAuthorization(authorization) {
        return experimental_signAuthorization({ ...authorization, privateKey });
      },
      async signMessage({ message }) {
        return signMessage2({ message, privateKey });
      },
      async signTransaction(transaction, { serializer } = {}) {
        return signTransaction2({ privateKey, transaction, serializer });
      },
      async signTypedData(typedData) {
        return signTypedData2({ ...typedData, privateKey });
      }
    });
    return {
      ...account,
      publicKey,
      source: "privateKey"
    };
  }

  // libs/shinkai-viem/src/index.ts
  window.viem = esm_exports;
  window.chains = chains_exports;
  var ViemProvider = class {
    client;
    selectedAddress;
    constructor(chain, sk) {
      const privateKey = sk || "0xf4c1c6d9231a5f08aa8d9824a142c4fc5a663ca1a6ecd61126e54a0d7501df82";
      const account = privateKeyToAccount(privateKey);
      this.client = createWalletClient({
        account,
        chain: chain || arbitrumSepolia,
        transport: http(
          "https://arbitrum-sepolia.blockpi.network/v1/rpc/public"
        )
      }).extend(publicActions);
      this.client.getAddresses().then((addresses) => {
        console.log("addresses", addresses);
        this.selectedAddress = addresses[0];
      });
    }
    async enable() {
      return this.requestAccounts();
    }
    async request({ method, params }) {
      console.log("request", method, params);
      switch (method) {
        case "eth_requestAccounts":
          return this.requestAccounts();
        case "eth_accounts":
          return this.getAccounts();
        case "eth_sendTransaction":
          return this.sendTransaction(params[0]);
        case "eth_sign":
          return this.sign(params[0], params[1]);
        case "personal_sign":
          return this.personalSign(params[0], params[1]);
        case "eth_signTypedData":
          return this.signTypedData(params[0], params[1]);
        case "eth_chainId":
          return this.getChainId();
        case "net_version":
          return this.getNetworkId();
        case "eth_blockNumber":
          return this.getBlockNumber();
        case "eth_getTransactionCount":
          return this.getTransactionCount(params[0]);
        case "eth_getTransactionByHash":
          return this.getTransaction(params[0]);
        case "eth_getTransactionReceipt":
          return this.getTransactionReceipt(params[0]);
        default:
          throw new Error(`Unsupported method: ${method}`);
      }
    }
    async getTransaction(hash3) {
      const transaction = await this.client.getTransaction({ hash: hash3 });
      console.log("getTransaction", transaction);
      if (transaction.type === "eip1559") {
        transaction.type = "0x2";
      }
      return transaction;
    }
    async getTransactionReceipt(hash3) {
      const receipt = await this.client.getTransactionReceipt({ hash: hash3 });
      console.log("getTransactionReceipt", receipt);
      if (receipt.type === "eip1559") {
        receipt.type = "0x2";
      }
      if (receipt.status === "success") {
        receipt.status = "0x1";
      }
      return receipt;
    }
    async getTransactionCount(address) {
      const transactionCount = await this.client.getTransactionCount({ address });
      console.log("transactionCount", transactionCount);
      return transactionCount;
    }
    async getBlockNumber() {
      const blockNumber = await this.client.getBlockNumber();
      console.log("blockNumber", blockNumber);
      return blockNumber;
    }
    async requestAccounts() {
      const [address] = await this.client.getAddresses();
      console.log("requestAccounts", address);
      this.selectedAddress = address;
      return [address];
    }
    async getAccounts() {
      return this.selectedAddress ? [this.selectedAddress] : [];
    }
    async sendTransaction(tx) {
      if (!this.selectedAddress) {
        throw new Error("No accounts available");
      }
      if (!tx.to || !tx.value || !tx.gas) {
        throw new Error("Missing required transaction parameters");
      }
      console.log("sendTransaction tx: ", tx);
      console.log("Transaction gasPrice: ", tx.gasPrice);
      console.log("Transaction gas: ", tx.gas);
      const value = BigInt(tx.value);
      const valueInEth = Number(value) / 10 ** 18;
      console.log(`Transaction value in ETH: ${valueInEth}`);
      const transactionContent = {
        to: tx.to,
        value,
        data: tx.data,
        chain: this.client.chain
      };
      console.log("sendTransaction", transactionContent);
      try {
        const request = await this.client.prepareTransactionRequest(transactionContent);
        console.log("Prepared transaction request:", request);
        const serializedTransaction = await this.client.signTransaction(request);
        console.log("Serialized transaction:", serializedTransaction);
        const hash3 = await this.client.sendRawTransaction({
          serializedTransaction
        });
        console.log("sendTransaction hash", hash3);
        return hash3;
      } catch (error) {
        console.error("sendTransaction error", error);
        throw error;
      }
    }
    async sign(address, message) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async personalSign(message, address) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signMessage({ account: address, message });
    }
    async signTypedData(address, typedData) {
      if (address !== this.selectedAddress) {
        throw new Error("Address mismatch");
      }
      return this.client.signTypedData({
        account: address,
        domain: typedData.domain,
        types: typedData.types,
        message: typedData.message,
        primaryType: typedData.primaryType
      });
    }
    async getChainId() {
      const chainId = await this.client.getChainId();
      console.log("getChainId", chainId);
      return chainId;
    }
    async getNetworkId() {
      const chainId = await this.getChainId();
      return chainId.toString();
    }
  };
  function addEip6963Listener(info, provider) {
    const announceEvent = new CustomEvent(
      "eip6963:announceProvider",
      {
        detail: Object.freeze({ info, provider })
      }
    );
    window.dispatchEvent(announceEvent);
    window.addEventListener("eip6963:requestProvider", () => {
      window.dispatchEvent(announceEvent);
    });
  }
  function initializeViemProvider(chain, providerInfo) {
    const provider = new ViemProvider(chain, null);
    window.ethereum = {
      request: provider.request.bind(provider),
      enable: provider.enable.bind(provider),
      on: (eventName, callback) => {
        console.log(`Event listener for ${eventName} added.`);
      },
      removeListener: (eventName, callback) => {
        console.log(`Event listener for ${eventName} removed.`);
      },
      isConnected: () => {
        return true;
      },
      send: (method, params) => {
        console.warn("send is deprecated. Use request instead.");
        return provider.request({ method, params });
      },
      sendAsync: (payload, callback) => {
        console.warn("sendAsync is deprecated. Use request instead.");
        provider.request({ method: payload.method, params: payload.params }).then((result) => callback(null, { result })).catch((error) => callback(error, null));
      },
      isMetaMask: true,
      // Set to true if mimicking MetaMask
      selectedAddress: provider.selectedAddress,
      chainId: chain?.id || "0x1"
      // Default to mainnet if chain is not provided
    };
    addEip6963Listener(providerInfo, provider);
    console.log("Viem provider initialized");
  }
  var viemProviderInfo = {
    uuid: "d69bc4c4-e43a-4d0a-83d7-b6e7b7504beb",
    name: "Shinkai Viem Provider",
    icon: "data:image/svg+xml;base64,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",
    // Base64 encoded icon
    rdns: "com.shinkai.desktop"
  };
  initializeViemProvider(arbitrumSepolia, viemProviderInfo);
})();
/*! Bundled license information:

@noble/hashes/esm/utils.js:
  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/modular.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/curve.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/abstract/weierstrass.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/_shortw_utils.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)

@noble/curves/esm/secp256k1.js:
  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
'); diff --git a/apps/shinkai-tool-defillama-tvl-rankings/src/index.ts b/apps/shinkai-tool-defillama-tvl-rankings/src/index.ts index 1b6a48f..69f7ef1 100644 --- a/apps/shinkai-tool-defillama-tvl-rankings/src/index.ts +++ b/apps/shinkai-tool-defillama-tvl-rankings/src/index.ts @@ -205,7 +205,7 @@ export const run: Run = ( ): Promise => { const chromePath = configurations?.chromePath || - process.env.CHROME_PATH || + Deno.env.get('CHROME_PATH') || chromePaths.chrome || chromePaths.chromium; return withPage(chromePath, async (page) => { diff --git a/apps/shinkai-tool-perplexity/src/index.ts b/apps/shinkai-tool-perplexity/src/index.ts index 8bae316..671f96a 100644 --- a/apps/shinkai-tool-perplexity/src/index.ts +++ b/apps/shinkai-tool-perplexity/src/index.ts @@ -23,7 +23,7 @@ export const run: Run = async ( }); const chromePath = configurations?.chromePath || - process.env.CHROME_PATH || + Deno.env.get('CHROME_PATH') || chromePaths.chrome || chromePaths.chromium; const browser = await playwright['chromium'].launch({ From 24b5e35c8d6d784cc353508f8862faf84409183e Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Wed, 27 Nov 2024 17:25:28 -0300 Subject: [PATCH 03/11] - fix: chrome path for ci --- .github/workflows/pr-check.yml | 1 - libs/shinkai-tools-runner/src/lib.test.rs | 40 +++++-------------- .../src/tools/deno_runner_options.rs | 8 +--- 3 files changed, 12 insertions(+), 37 deletions(-) diff --git a/.github/workflows/pr-check.yml b/.github/workflows/pr-check.yml index 4cfe542..34e949e 100644 --- a/.github/workflows/pr-check.yml +++ b/.github/workflows/pr-check.yml @@ -67,6 +67,5 @@ jobs: env: CHROME_PATH: ${{ steps.setup-chrome.outputs.chrome-path }} EMBEDDING_API_URL : ${{ vars.EMBEDDING_API_URL }} - CI_FORCE_RUNNER_TYPE: host run: | npx nx run-many -t test --parallel=false --skip-nx-cache diff --git a/libs/shinkai-tools-runner/src/lib.test.rs b/libs/shinkai-tools-runner/src/lib.test.rs index 499e6a2..0350c9b 100644 --- a/libs/shinkai-tools-runner/src/lib.test.rs +++ b/libs/shinkai-tools-runner/src/lib.test.rs @@ -511,9 +511,14 @@ async fn shinkai_tool_playwright_example(#[case] runner_type: RunnerType) { files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), entrypoint: "main.ts".to_string(), }; + let tool = Tool::new( code_files, - serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }), + if matches!(runner_type, RunnerType::Docker) && std::env::var("CI").is_ok() { + serde_json::json!({}) + } else { + serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }) + }, Some(DenoRunnerOptions { force_runner_type: Some(runner_type), ..Default::default() @@ -558,7 +563,11 @@ async fn shinkai_tool_defillama_lending_tvl_rankings(#[case] runner_type: Runner }; let tool = Tool::new( code_files, - serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }), + if matches!(runner_type, RunnerType::Docker) && std::env::var("CI").is_ok() { + serde_json::json!({}) + } else { + serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }) + }, Some(DenoRunnerOptions { force_runner_type: Some(runner_type), ..Default::default() @@ -579,33 +588,6 @@ async fn shinkai_tool_defillama_lending_tvl_rankings(#[case] runner_type: Runner assert_eq!(run_result.unwrap().data["rowsCount"], 43); } -// // TODO: enable this test again when fix the tool -// #[tokio::test] -// async fn shinkai_tool_aave_loan_requester() { -// let _ = env_logger::builder() -// .filter_level(log::LevelFilter::Info) -// .is_test(true) -// .try_init(); -// let tool_definition = get_tool("shinkai-tool-aave-loan-requester").unwrap(); -// let code_files = CodeFiles { -// files: HashMap::from([("main.ts".to_string(), tool_definition.code.clone().unwrap())]), -// entrypoint: "main.ts".to_string(), -// }; -// let tool = Tool::new( -// code_files, -// serde_json::json!({ "chromePath": std::env::var("CHROME_PATH").ok().unwrap_or("".to_string()) }), -// None, -// ); -// let run_result = tool -// .run( -// None, -// serde_json::json!({ "inputValue": "0.005", "assetSymbol": "ETH" }), -// None, -// ) -// .await; -// assert!(run_result.is_ok()); -// } - #[rstest] #[case::host(RunnerType::Host)] #[case::docker(RunnerType::Docker)] diff --git a/libs/shinkai-tools-runner/src/tools/deno_runner_options.rs b/libs/shinkai-tools-runner/src/tools/deno_runner_options.rs index 1bda3a2..af75f4c 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_runner_options.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_runner_options.rs @@ -34,13 +34,7 @@ impl Default for DenoRunnerOptions { } else { "./shinkai-tools-runner-resources/deno" }), - force_runner_type: std::env::var("CI_FORCE_RUNNER_TYPE") - .map(|val| match val.as_str() { - "host" => Some(RunnerType::Host), - "docker" => Some(RunnerType::Docker), - _ => None, - }) - .unwrap_or(None), + force_runner_type: None, shinkai_node_location: ShinkaiNodeLocation { protocol: String::from("http"), host: String::from("127.0.0.1"), From ff771b48b4fa29f1fe302cb37b6f5d63704bf84a Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 10:09:18 -0300 Subject: [PATCH 04/11] - fix: disable chrome tests in windows --- apps/shinkai-tool-aave-state/src/index.test.ts | 1 + .../src/index.test.ts | 9 +++++---- apps/shinkai-tool-perplexity/src/index.test.ts | 2 +- apps/shinkai-tool-playwright-example/src/index.test.ts | 1 + 4 files changed, 8 insertions(+), 5 deletions(-) diff --git a/apps/shinkai-tool-aave-state/src/index.test.ts b/apps/shinkai-tool-aave-state/src/index.test.ts index fd90c23..596d289 100644 --- a/apps/shinkai-tool-aave-state/src/index.test.ts +++ b/apps/shinkai-tool-aave-state/src/index.test.ts @@ -6,6 +6,7 @@ Deno.test({ name: 'echo', sanitizeResources: false, sanitizeOps: false, + ignore: Deno.build.os === 'windows', fn: async () => { const result = await run( { diff --git a/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts b/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts index a9f3fc6..f027d85 100644 --- a/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts +++ b/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts @@ -6,9 +6,10 @@ Deno.test('exists definition', () => { expect(definition).toBeInstanceOf(Object); }); -Deno.test( - 'run using top10=false, categoryName=Liquid Staking, networkName=Ethereum', - async () => { +Deno.test({ + name: 'run using top10=false, categoryName=Liquid Staking, networkName=Ethereum', + ignore: Deno.env.get('CI') === 'true' || Deno.build.os === 'windows', + fn: async () => { const run_result = await run( { chromePath: process.env?.CHROME_PATH, @@ -23,7 +24,7 @@ Deno.test( expect(run_result.columnsCount).toEqual(12); expect(run_result.rowsCount).toBeGreaterThan(10); }, -); +}); Deno.test('test `findNetworkName` method', () => { expect(findNetworkName('base')).toEqual('Base'); diff --git a/apps/shinkai-tool-perplexity/src/index.test.ts b/apps/shinkai-tool-perplexity/src/index.test.ts index 4a15fe2..40b7a33 100644 --- a/apps/shinkai-tool-perplexity/src/index.test.ts +++ b/apps/shinkai-tool-perplexity/src/index.test.ts @@ -9,7 +9,7 @@ Deno.test('exists definition', () => { Deno.test({ name: 'run', // Perplexity web scrapping is not working in CI (need to figure out why) - ignore: Deno.env.get('CI') === 'true', + ignore: Deno.env.get('CI') === 'true' || Deno.build.os === 'windows', fn: async () => { const run_result = await run( { diff --git a/apps/shinkai-tool-playwright-example/src/index.test.ts b/apps/shinkai-tool-playwright-example/src/index.test.ts index bbb72e5..2402cb6 100644 --- a/apps/shinkai-tool-playwright-example/src/index.test.ts +++ b/apps/shinkai-tool-playwright-example/src/index.test.ts @@ -12,6 +12,7 @@ Deno.test({ }, sanitizeResources: false, sanitizeOps: false, + ignore: Deno.build.os === 'windows', fn: async () => { const result = await run( { From 3dda35ec7b93d71ea0b1568bb21e1e271c1dfa10 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 11:31:46 -0300 Subject: [PATCH 05/11] - fix: removed unused code --- .../shinkai-tool-aave-state/src/index.test.ts | 2 +- .../src/built_in_tools.test.rs | 26 ---------- libs/shinkai-tools-runner/src/tools/tool.rs | 51 ------------------- .../src/tools/tool.test.rs | 33 ------------ 4 files changed, 1 insertion(+), 111 deletions(-) diff --git a/apps/shinkai-tool-aave-state/src/index.test.ts b/apps/shinkai-tool-aave-state/src/index.test.ts index 596d289..b9be3ab 100644 --- a/apps/shinkai-tool-aave-state/src/index.test.ts +++ b/apps/shinkai-tool-aave-state/src/index.test.ts @@ -6,7 +6,7 @@ Deno.test({ name: 'echo', sanitizeResources: false, sanitizeOps: false, - ignore: Deno.build.os === 'windows', + ignore: Deno.env.get('CI') === 'true' || Deno.build.os === 'windows', fn: async () => { const result = await run( { diff --git a/libs/shinkai-tools-runner/src/built_in_tools.test.rs b/libs/shinkai-tools-runner/src/built_in_tools.test.rs index 7302454..c084707 100644 --- a/libs/shinkai-tools-runner/src/built_in_tools.test.rs +++ b/libs/shinkai-tools-runner/src/built_in_tools.test.rs @@ -7,32 +7,6 @@ use crate::{ tools::code_files::CodeFiles, }; -#[tokio::test] -async fn get_tools_all_load() { - let _ = env_logger::builder() - .filter_level(log::LevelFilter::Info) - .is_test(true) - .try_init(); - let tools = get_tools(); - for (tool_name, tool_definition) in tools { - println!("creating tool instance for {}", tool_name); - let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), tool_definition.code.unwrap())]), - entrypoint: "main.ts".to_string(), - }; - let tool_instance = crate::tools::tool::Tool::new(code_files, Value::Null, None); - println!("fetching definition for {}", tool_name); - let defintion = tool_instance.definition().await; - println!( - "definition load successfully for {}: {:?}", - tool_name, - defintion.clone().unwrap().id - ); - assert_eq!(defintion.as_ref().unwrap().id, tool_name); - assert!(defintion.is_ok(), "tool {} failed to load", tool_name); - } -} - #[tokio::test] async fn list_tools_count() { assert!(get_tools().len() >= 5); diff --git a/libs/shinkai-tools-runner/src/tools/tool.rs b/libs/shinkai-tools-runner/src/tools/tool.rs index e5021cb..1506a9d 100644 --- a/libs/shinkai-tools-runner/src/tools/tool.rs +++ b/libs/shinkai-tools-runner/src/tools/tool.rs @@ -29,57 +29,6 @@ impl Tool { } } - pub async fn definition(&self) -> Result { - log::info!("preparing to get tool definition from code"); - - let mut deno_runner = DenoRunner::new(self.deno_runner_options.clone()); - - let mut code = self.code.clone(); - let entrypoint_code = code.files.get(&self.code.entrypoint.clone()); - if let Some(entrypoint_code) = entrypoint_code { - let adapted_entrypoint_code = format!( - r#" - {} - console.log(""); - console.log(JSON.stringify(definition)); - console.log(""); - "#, - entrypoint_code - ); - code.files.insert( - self.code.entrypoint.clone(), - adapted_entrypoint_code.clone(), - ); - } - - let result = deno_runner - .run(code, None, None) - .await - .map_err(|e| ExecutionError::new(format!("failed to run deno: {}", e), None))?; - - let result_text = result - .iter() - .skip_while(|line| !line.contains("")) - .skip(1) - .take_while(|line| !line.contains("")) - .map(|s| s.to_string()) - .collect::>() - .join("\n"); - - log::info!("result text: {}", result_text); - - let tool_definition: ToolDefinition = serde_json::from_str(&result_text).map_err(|e| { - log::info!("failed to parse tool definition: {}", e); - ExecutionError::new(format!("failed to parse tool definition: {}", e), None) - })?; - - log::info!( - "successfully retrieved tool definition: {:?}", - tool_definition - ); - Ok(tool_definition) - } - pub async fn check(&self) -> anyhow::Result> { let mut deno_runner = DenoRunner::new(self.deno_runner_options.clone()); let code = self.code.clone(); diff --git a/libs/shinkai-tools-runner/src/tools/tool.test.rs b/libs/shinkai-tools-runner/src/tools/tool.test.rs index 236ec47..5fca3be 100644 --- a/libs/shinkai-tools-runner/src/tools/tool.test.rs +++ b/libs/shinkai-tools-runner/src/tools/tool.test.rs @@ -10,39 +10,6 @@ use crate::tools::{ tool::Tool, }; -#[rstest] -#[case::host(RunnerType::Host)] -#[case::docker(RunnerType::Docker)] -#[tokio::test] -async fn get_tool_definition(#[case] runner_type: RunnerType) { - // Just for a simple test, it could be any tool - let code = include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../apps/shinkai-tool-echo/src/index.ts" - )) - .to_string(); - - let code_files = CodeFiles { - files: HashMap::from([("main.ts".to_string(), code.to_string())]), - entrypoint: "main.ts".to_string(), - }; - - let configurations = serde_json::json!({}); - - let tool = Tool::new( - code_files, - configurations, - Some(DenoRunnerOptions { - force_runner_type: Some(runner_type), - ..Default::default() - }), - ); - - let definition = tool.definition().await.unwrap(); - - assert_eq!(definition.id, "shinkai-tool-echo"); -} - #[rstest] #[case::host(RunnerType::Host)] #[case::docker(RunnerType::Docker)] From 809443db2658647fa185573676eb40e8039ebe13 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 12:17:19 -0300 Subject: [PATCH 06/11] - fix: tests --- libs/shinkai-tools-runner/src/built_in_tools.test.rs | 9 +-------- libs/shinkai-tools-runner/src/copy_assets.rs | 2 +- libs/shinkai-tools-runner/src/tools/deno_runner.rs | 6 ++++-- libs/shinkai-tools-runner/src/tools/tool.rs | 2 +- 4 files changed, 7 insertions(+), 12 deletions(-) diff --git a/libs/shinkai-tools-runner/src/built_in_tools.test.rs b/libs/shinkai-tools-runner/src/built_in_tools.test.rs index c084707..10475f2 100644 --- a/libs/shinkai-tools-runner/src/built_in_tools.test.rs +++ b/libs/shinkai-tools-runner/src/built_in_tools.test.rs @@ -1,11 +1,4 @@ -use std::collections::HashMap; - -use serde_json::Value; - -use crate::{ - built_in_tools::{get_tool, get_tools}, - tools::code_files::CodeFiles, -}; +use crate::built_in_tools::{get_tool, get_tools}; #[tokio::test] async fn list_tools_count() { diff --git a/libs/shinkai-tools-runner/src/copy_assets.rs b/libs/shinkai-tools-runner/src/copy_assets.rs index f8554d3..b4cc824 100644 --- a/libs/shinkai-tools-runner/src/copy_assets.rs +++ b/libs/shinkai-tools-runner/src/copy_assets.rs @@ -5,7 +5,7 @@ use std::io::Write; use std::path::Path; use std::path::PathBuf; -pub static DENO_VERSION: &str = "v2.0.4"; +pub static DENO_VERSION: &str = "v2.1.1"; static PROFILE: Lazy = Lazy::new(|| std::env::var("PROFILE").unwrap_or_else(|_| "debug".to_string())); diff --git a/libs/shinkai-tools-runner/src/tools/deno_runner.rs b/libs/shinkai-tools-runner/src/tools/deno_runner.rs index 7c2fa44..a1b9e21 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_runner.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_runner.rs @@ -330,7 +330,7 @@ impl DenoRunner { }); #[allow(clippy::let_underscore_future)] - let _ = tokio::spawn(async move { + let std_tasks = tokio::spawn(async move { let _ = futures::future::join_all(vec![stdout_task, stderr_task]).await; }); @@ -350,6 +350,7 @@ impl DenoRunner { log::info!("executing command without timeout"); child.wait_with_output().await? }; + let _ = std_tasks.await; if !output.status.success() { let stderr = stderr_lines.lock().await.to_vec().join("\n"); log::error!("command execution failed: {}", stderr); @@ -489,7 +490,7 @@ impl DenoRunner { }); #[allow(clippy::let_underscore_future)] - let _ = tokio::spawn(async move { + let std_tasks = tokio::spawn(async move { let _ = futures::future::join_all(vec![stdout_task, stderr_task]).await; }); @@ -509,6 +510,7 @@ impl DenoRunner { log::info!("executing command without timeout"); child.wait_with_output().await? }; + let _ = std_tasks.await; if !output.status.success() { let stderr = stderr_lines.lock().await.to_vec().join("\n"); log::error!("command execution failed: {}", stderr); diff --git a/libs/shinkai-tools-runner/src/tools/tool.rs b/libs/shinkai-tools-runner/src/tools/tool.rs index 1506a9d..d0250fa 100644 --- a/libs/shinkai-tools-runner/src/tools/tool.rs +++ b/libs/shinkai-tools-runner/src/tools/tool.rs @@ -4,7 +4,7 @@ use serde_json::Value; use super::{ code_files::CodeFiles, deno_runner::DenoRunner, deno_runner_options::DenoRunnerOptions, - execution_error::ExecutionError, run_result::RunResult, tool_definition::ToolDefinition, + execution_error::ExecutionError, run_result::RunResult, }; pub struct Tool { From 7ba40223070e93aa61073dc604192b76a6e9be59 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 13:27:32 -0300 Subject: [PATCH 07/11] - fix: thread concurrency --- libs/shinkai-tools-runner/project.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/shinkai-tools-runner/project.json b/libs/shinkai-tools-runner/project.json index 74fbe8b..2bd3677 100644 --- a/libs/shinkai-tools-runner/project.json +++ b/libs/shinkai-tools-runner/project.json @@ -38,7 +38,7 @@ "defaultConfiguration": "development", "options": { "cwd": "libs/shinkai-tools-runner", - "command": "cargo test --features=built-in-tools" + "command": "cargo test --features=built-in-tools -- --test-threads=1" }, "configurations": { "development": {}, From 81e8238f5cbbb194dbf1c15d8310f8b6b00a5d37 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 13:42:38 -0300 Subject: [PATCH 08/11] - feature: added context id envs --- .../src/tools/deno_runner.rs | 7 +++ .../src/tools/tool.test.rs | 46 +++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/libs/shinkai-tools-runner/src/tools/deno_runner.rs b/libs/shinkai-tools-runner/src/tools/deno_runner.rs index a1b9e21..763ff96 100644 --- a/libs/shinkai-tools-runner/src/tools/deno_runner.rs +++ b/libs/shinkai-tools-runner/src/tools/deno_runner.rs @@ -223,6 +223,10 @@ impl DenoRunner { container_envs.push(format!("ASSETS={}", mount_assets_env)); container_envs.push(String::from("-e")); container_envs.push(format!("MOUNT={}", mount_env)); + container_envs.push(String::from("-e")); + container_envs.push(format!("CONTEXT_ID={}", self.options.context.context_id)); + container_envs.push(String::from("-e")); + container_envs.push(format!("EXECUTION_ID={}", self.options.context.execution_id)); if let Some(envs) = envs { for (key, value) in envs { @@ -446,6 +450,9 @@ impl DenoRunner { .join(","), ); + command.env("CONTEXT_ID", self.options.context.context_id.clone()); + command.env("EXECUTION_ID", self.options.context.execution_id.clone()); + if let Some(envs) = envs { command.envs(envs); } diff --git a/libs/shinkai-tools-runner/src/tools/tool.test.rs b/libs/shinkai-tools-runner/src/tools/tool.test.rs index 5fca3be..83fcd4c 100644 --- a/libs/shinkai-tools-runner/src/tools/tool.test.rs +++ b/libs/shinkai-tools-runner/src/tools/tool.test.rs @@ -610,3 +610,49 @@ async fn multiple_file_imports(#[case] runner_type: RunnerType) { assert!(result.is_ok()); assert_eq!(result.unwrap().data, "processed test data"); } + +#[rstest] +#[case::host(RunnerType::Host)] +#[case::docker(RunnerType::Docker)] +#[tokio::test] +async fn context_and_execution_id(#[case] runner_type: RunnerType) { + let _ = env_logger::builder() + .filter_level(log::LevelFilter::Info) + .is_test(true) + .try_init(); + + let context_id = nanoid::nanoid!(); + let execution_id = nanoid::nanoid!(); + + let code = r#" + function run() { + return { + contextId: Deno.env.get("CONTEXT_ID"), + executionId: Deno.env.get("EXECUTION_ID") + }; + } + "#; + + let code_files = CodeFiles { + files: HashMap::from([("main.ts".to_string(), code.to_string())]), + entrypoint: "main.ts".to_string(), + }; + + let tool = Tool::new( + code_files, + Value::Null, + Some(DenoRunnerOptions { + force_runner_type: Some(runner_type), + context: ExecutionContext { + context_id: context_id.clone(), + execution_id: execution_id.clone(), + ..Default::default() + }, + ..Default::default() + }), + ); + let result = tool.run(None, Value::Null, None).await.unwrap(); + + assert_eq!(result.data["contextId"], context_id); + assert_eq!(result.data["executionId"], execution_id); +} From e0e654a1317d1b858c79b05212e4dadab3c61fa9 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 14:00:21 -0300 Subject: [PATCH 09/11] - fix: deno warnings --- apps/shinkai-tool-aave-state/src/index.test.ts | 3 +-- .../src/index.test.ts | 2 +- apps/shinkai-tool-perplexity/src/index.test.ts | 2 +- .../src/index.test.ts | 2 +- .../src/index.ts | 2 +- scripts/tool-bundler.ts | 17 ++++++++--------- 6 files changed, 13 insertions(+), 15 deletions(-) diff --git a/apps/shinkai-tool-aave-state/src/index.test.ts b/apps/shinkai-tool-aave-state/src/index.test.ts index b9be3ab..054293c 100644 --- a/apps/shinkai-tool-aave-state/src/index.test.ts +++ b/apps/shinkai-tool-aave-state/src/index.test.ts @@ -1,4 +1,3 @@ -import process from 'node:process'; import { run } from './index.ts'; import { expect } from 'jsr:@std/expect'; @@ -10,7 +9,7 @@ Deno.test({ fn: async () => { const result = await run( { - chromePath: process.env?.CHROME_PATH, + chromePath: Deno.env.get('CHROME_PATH'), }, {}, ); diff --git a/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts b/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts index f027d85..3a2b53a 100644 --- a/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts +++ b/apps/shinkai-tool-defillama-tvl-rankings/src/index.test.ts @@ -12,7 +12,7 @@ Deno.test({ fn: async () => { const run_result = await run( { - chromePath: process.env?.CHROME_PATH, + chromePath: Deno.env.get('CHROME_PATH'), }, { top10: false, diff --git a/apps/shinkai-tool-perplexity/src/index.test.ts b/apps/shinkai-tool-perplexity/src/index.test.ts index 40b7a33..5347177 100644 --- a/apps/shinkai-tool-perplexity/src/index.test.ts +++ b/apps/shinkai-tool-perplexity/src/index.test.ts @@ -13,7 +13,7 @@ Deno.test({ fn: async () => { const run_result = await run( { - chromePath: process.env?.CHROME_PATH, + chromePath: Deno.env.get('CHROME_PATH'), }, { query: 'What is the meaning of life?', diff --git a/apps/shinkai-tool-playwright-example/src/index.test.ts b/apps/shinkai-tool-playwright-example/src/index.test.ts index 2402cb6..52715ff 100644 --- a/apps/shinkai-tool-playwright-example/src/index.test.ts +++ b/apps/shinkai-tool-playwright-example/src/index.test.ts @@ -16,7 +16,7 @@ Deno.test({ fn: async () => { const result = await run( { - chromePath: process.env?.CHROME_PATH, + chromePath: Deno.env.get('CHROME_PATH'), }, { url: 'https://shinkai.com' }, ); diff --git a/apps/shinkai-tool-playwright-example/src/index.ts b/apps/shinkai-tool-playwright-example/src/index.ts index 29721b4..44e0354 100644 --- a/apps/shinkai-tool-playwright-example/src/index.ts +++ b/apps/shinkai-tool-playwright-example/src/index.ts @@ -16,7 +16,7 @@ export const run: Run = async ( ): Promise => { const chromePath = configurations?.chromePath || - process.env.CHROME_PATH || + Deno.env.get('CHROME_PATH') || chromePaths.chrome || chromePaths.chromium; diff --git a/scripts/tool-bundler.ts b/scripts/tool-bundler.ts index 236e1e9..db929e3 100644 --- a/scripts/tool-bundler.ts +++ b/scripts/tool-bundler.ts @@ -1,14 +1,14 @@ /** * Script to bundle and process Shinkai tools - * + * * This script takes an entry file and output folder as arguments, bundles the tool code, * generates embeddings for the tool definition, and creates an extended tool definition * that includes the code and embedding metadata. - * + * * Usage: * Run with --entry and --outputFolder parameters: * deno run tool-bundler.ts --entry= --outputFolder= - * + * * The script will: * 1. Read and bundle the tool code from the entry file * 2. Write the bundled code to index.ts in the output folder @@ -21,7 +21,6 @@ import { join } from 'node:path'; import minimist from 'npm:minimist'; import fs from 'node:fs'; -import process from 'node:process'; import axios from 'npm:axios'; console.log('🚀 Starting Shinkai Tool bundler...'); @@ -37,9 +36,9 @@ type ExtendedToolDefinition = ToolDefinition & { // Parse command line arguments console.log('📝 Parsing command line arguments...'); -const args = minimist(process.argv.slice(2)); -const entryFile: string = join(process.cwd(), args.entry); -const outputFolder: string = join(process.cwd(), args.outputFolder); +const args = minimist(Deno.args.slice(2)); +const entryFile: string = join(Deno.cwd(), args.entry); +const outputFolder: string = join(Deno.cwd(), args.outputFolder); const outputFile: string = join(outputFolder, 'index.ts'); console.log('📂 Entry file:', entryFile); @@ -79,7 +78,7 @@ fs.promises // Import tool definition from bundled code console.log('📥 Importing tool definition...'); const { definition }: { definition: ToolDefinition } = await import( - process.platform === 'win32' ? `file://${outputFile}` : outputFile + Deno.build.os == 'windows' ? `file://${outputFile}` : outputFile ); console.log('✨ Tool definition loaded:', definition.name); @@ -88,7 +87,7 @@ fs.promises console.log('🧮 Generating embeddings for tool metadata...'); const prompt = `${definition.id} ${definition.name} ${definition.description} ${definition.author} ${definition.keywords.join(' ')}`; const embeddings = await getEmbeddings(prompt); - + // Create extended tool definition with code and embeddings console.log('🔨 Creating extended tool definition...'); const toolDefinition: ExtendedToolDefinition = { From 2f68231d98d54e9fcd2b61808f8140afd23b26cf Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 14:02:58 -0300 Subject: [PATCH 10/11] - fix: deno args --- scripts/tool-bundler.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/tool-bundler.ts b/scripts/tool-bundler.ts index db929e3..6ccfa17 100644 --- a/scripts/tool-bundler.ts +++ b/scripts/tool-bundler.ts @@ -36,7 +36,7 @@ type ExtendedToolDefinition = ToolDefinition & { // Parse command line arguments console.log('📝 Parsing command line arguments...'); -const args = minimist(Deno.args.slice(2)); +const args = minimist(Deno.args); const entryFile: string = join(Deno.cwd(), args.entry); const outputFolder: string = join(Deno.cwd(), args.outputFolder); const outputFile: string = join(outputFolder, 'index.ts'); From efd05016ff5aa697e1ec807c3ad411765b3f0bd7 Mon Sep 17 00:00:00 2001 From: Alfredo Gallardo Date: Thu, 28 Nov 2024 14:08:14 -0300 Subject: [PATCH 11/11] - fix: removed unused var --- apps/shinkai-tool-playwright-example/src/index.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/apps/shinkai-tool-playwright-example/src/index.ts b/apps/shinkai-tool-playwright-example/src/index.ts index 44e0354..af12800 100644 --- a/apps/shinkai-tool-playwright-example/src/index.ts +++ b/apps/shinkai-tool-playwright-example/src/index.ts @@ -1,6 +1,5 @@ import * as playwright from 'npm:playwright@1.48.2'; import chromePaths from 'npm:chrome-paths@1.0.1'; -import process from 'node:process'; type Configurations = { chromePath?: string;